home *** CD-ROM | disk | FTP | other *** search
/ MacFormat España 4 / MacFormat n. 4 (Spain) / MacFormat 4.bin / La ciudad del ShareWare / Desarrollo / OutOfPhase1.1 Source / OutOfPhase Folder / PcodeSystem.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-28  |  137.4 KB  |  3,213 lines
  1. /* PcodeSystem.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #define SHOW_ME_OPCODEREC  /* we need to see the internals of OpcodeRec */
  31. #define SHOW_ME_STACKELEMENT  /* we also need to be able to see into stack elements */
  32. #include "PcodeSystem.h"
  33. #include "Memory.h"
  34. #include "EventLoop.h"
  35. #include "DataMunging.h"
  36. #include "Alert.h"
  37. #include "FloatingPoint.h"
  38. #include "PcodeStack.h"
  39. #include "PcodeObject.h"
  40. #include "CodeCenter.h"
  41. #include "FunctionCode.h"
  42. #include "InteractionWindow.h"
  43. #include "Numbers.h"
  44.  
  45.  
  46. /* number of pcode execution cycles between relinquish CPU calls */
  47. #if DEBUG
  48.     #define WIZZBANGCOUNTINITIALIZER (1024L) /* give us some responsiveness when debugging */
  49. #else
  50.     #define WIZZBANGCOUNTINITIALIZER (65536L)
  51. #endif
  52.  
  53.  
  54. EvalErrors                EvaluatePcode(struct ParamStackRec* Prep, struct PcodeRec* Pcode,
  55.                                         struct CodeCenterRec* CodeCenter, union OpcodeRec** OffendingPcode,
  56.                                         long* OffendingInstruction, void* Refcon,
  57.                                         SampleErrors (*GetSampleLeftCopy)(void* Refcon, char* SampleName,
  58.                                             largefixedsigned** SampleData),
  59.                                         SampleErrors (*GetSampleRightCopy)(void* Refcon, char* SampleName,
  60.                                             largefixedsigned** SampleData),
  61.                                         SampleErrors (*GetSampleMiddleCopy)(void* Refcon, char* SampleName,
  62.                                             largefixedsigned** SampleData),
  63.                                         SampleErrors (*GetWaveTableFrameCount)(void* Refcon,
  64.                                             char* WaveTableName, long* FrameCountOut),
  65.                                         SampleErrors (*GetWaveTableTableCount)(void* Refcon,
  66.                                             char* WaveTableName, long* TableCountOut),
  67.                                         SampleErrors (*GetWaveTableCopy)(void* Refcon, char* WaveTableName,
  68.                                             largefixedsigned** WaveTableData),
  69.                                         void* IRefCon,
  70.                                         struct InteractionWindowRec* (*GetInteractionWindow)(void* IRefCon))
  71.     {
  72.         /* machine variables */
  73.         StackElement*        Stack;
  74.         long                        StackSize;
  75.         long                        StackPtr;
  76.         long                        ProgramCounter;
  77.         OpcodeRec*            CurrentProcedure;
  78.         long                        Index;
  79.         long                        Scan;
  80.         EvalErrors            ErrorCode;
  81.         long                        WizzBangCount;
  82.         long                        FuncCallDepth;
  83.  
  84.  
  85.         /* check everything out */
  86.         ERROR(OffendingPcode == NIL,PRERR(ForceAbort,
  87.             "EvaluatePcode:  OffendingPcode is NIL"));
  88.         ERROR(OffendingInstruction == NIL,PRERR(ForceAbort,
  89.             "EvaluatePcode:  OffendingInstruction is NIL"));
  90.         CheckPtrExistence(Prep);
  91.         CheckPtrExistence(Pcode);
  92.  
  93.         /* initialize variables */
  94.         Stack = GetStackBase(Prep);
  95.         StackSize = GetStackInitialSize(Prep);
  96.         StackPtr = GetStackNumElements(Prep) - 1;
  97.         ProgramCounter = 0;
  98.         CurrentProcedure = GetOpcodeFromPcode(Pcode);
  99.         FuncCallDepth = 0;
  100.  
  101.         /* main execution loop.  this ends when there is nothing on the stack and */
  102.         /* something tries to execute a return from subroutine, which means the outermost */
  103.         /* procedure is returning.  the final return value of the program will be in P. */
  104.         WizzBangCount = 0;
  105.         while (1)
  106.             {
  107.                 WizzBangCount -= 1;
  108.                 if (WizzBangCount <= 0)
  109.                     {
  110.                         WizzBangCount = WIZZBANGCOUNTINITIALIZER;
  111.                         if (RelinquishCPUJudiciouslyCheckCancel())
  112.                             {
  113.                                 ErrorCode = eEvalUserCancelled;
  114.                                 goto ExceptionPoint;
  115.                             }
  116.                     }
  117.                 PRNGCHK(CurrentProcedure,&(CurrentProcedure[ProgramCounter].Opcode),
  118.                     sizeof(CurrentProcedure[ProgramCounter].Opcode));
  119.                 switch (CurrentProcedure[ProgramCounter++].Opcode)
  120.                     {
  121.  
  122.                         default:
  123.                             EXECUTE(PRERR(ForceAbort,"EvaluatePcode:  unknown opcode evaluated"));
  124.                             break;
  125.  
  126.                         case epFuncCallUnresolved:
  127.                             /* an unresolved function call.  try to resolve it */
  128.                             /*     -1           0               1           2             3   */
  129.                             /* <opcode> ^"<functionname>" ^[paramlist] <returntype> <reserved> */
  130.                             {
  131.                                 FuncCodeRec*        Function;
  132.                                 DataTypes*            ParameterList;
  133.                                 long                        Limit;
  134.  
  135.                                 /* special note: we can't dispose of what we get from CodeCenter */
  136.                                 /* because it gives us the real thing, not a copy */
  137.                                 PRNGCHK(CurrentProcedure,
  138.                                     &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  139.                                     sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  140.                                 Function = ObtainFunctionHandle(CodeCenter,
  141.                                     &(*(CurrentProcedure[ProgramCounter + 0].ImmediateString)),
  142.                                     StrLen(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  143.                                 if (Function == NIL)
  144.                                     {
  145.                                         ErrorCode = eEvalUndefinedFunction;
  146.                                         goto ExceptionPoint;
  147.                                     }
  148.                                 ParameterList = GetFunctionParameterTypeList(Function);
  149.                                 PRNGCHK(CurrentProcedure,
  150.                                     &(CurrentProcedure[ProgramCounter + 1].DataTypeArray),
  151.                                     sizeof(CurrentProcedure[ProgramCounter + 1].DataTypeArray));
  152.                                 Limit = PtrSize((char*)CurrentProcedure[ProgramCounter
  153.                                     + 1].DataTypeArray);
  154.                                 if (PtrSize((char*)ParameterList) != Limit)
  155.                                     {
  156.                                         /* different number of parameters */
  157.                                         ErrorCode = eEvalWrongNumParametersForFunction;
  158.                                         goto ExceptionPoint;
  159.                                     }
  160.                                 Limit = Limit / sizeof(DataTypes);
  161.                                 for (Index = 0; Index < Limit; Index += 1)
  162.                                     {
  163.                                         if (CurrentProcedure[ProgramCounter + 1].DataTypeArray[Index]
  164.                                             != ParameterList[Index])
  165.                                             {
  166.                                                 /* parameters of different types */
  167.                                                 ErrorCode = eEvalWrongParameterType;
  168.                                                 goto ExceptionPoint;
  169.                                             }
  170.                                     }
  171.                                 PRNGCHK(CurrentProcedure,
  172.                                     &(CurrentProcedure[ProgramCounter + 2].ImmediateInteger),
  173.                                     sizeof(CurrentProcedure[ProgramCounter + 2].ImmediateInteger));
  174.                                 if ((DataTypes)(CurrentProcedure[ProgramCounter + 2].ImmediateInteger)
  175.                                     != GetFunctionReturnType(Function))
  176.                                     {
  177.                                         /* different return types */
  178.                                         ErrorCode = eEvalWrongReturnType;
  179.                                         goto ExceptionPoint;
  180.                                     }
  181.                                 /* finally, the function appears to be the one we want. */
  182.                                 PRNGCHK(CurrentProcedure,
  183.                                     &(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr),
  184.                                     sizeof(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr));
  185.                                 /* first, install the PcodeRec in the instruction */
  186.                                 CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr
  187.                                     = GetOpcodeFromPcode(GetFunctionPcode(Function));
  188.                                 /* next, change the instruction to epFuncCallResolved */
  189.                                 CurrentProcedure[ProgramCounter - 1].Opcode = epFuncCallResolved;
  190.                             }
  191.                             goto epFunctionCallResolvedPoint;
  192.  
  193.                         case epFuncCallResolved:
  194.                          epFunctionCallResolvedPoint:
  195.                             /* a function call whose destination is known. */
  196.                             /*     -1           0               1           2             3    */
  197.                             /* <opcode> ^"<functionname>" ^[paramlist] <returntype> ^<OpcodeRec> */
  198.                             PRNGCHK(CurrentProcedure,
  199.                                 &(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr),
  200.                                 sizeof(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr));
  201.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 3]
  202.                                 .FunctionOpcodeRecPtr);
  203.                             StackPtr += 1;
  204.                             if (StackPtr >= StackSize)
  205.                                 {
  206.                                     StackElement*            NewStack;
  207.  
  208.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  209.                                         * sizeof(StackElement));
  210.                                     if (NewStack == NIL)
  211.                                         {
  212.                                             StackPtr -= 1;
  213.                                             ErrorCode = eEvalOutOfMemory;
  214.                                             goto ExceptionPoint;
  215.                                         }
  216.                                     Stack = NewStack;
  217.                                     StackSize += 8;
  218.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  219.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  220.                                 }
  221.                             /* store return address on stack.  the return address is the address */
  222.                             /* of the NEXT instruction. */
  223.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  224.                             Stack[StackPtr].ElementType = esReturnAddress;
  225.                             Stack[StackPtr].Data.ReturnAddress.Procedure = CurrentProcedure;
  226.                             Stack[StackPtr].Data.ReturnAddress.Index
  227.                                 = ProgramCounter + 4; /* 4 words to skip */
  228.                             /* perform the jump */
  229.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 3].FunctionOpcodeRecPtr);
  230.                             CurrentProcedure = CurrentProcedure[ProgramCounter + 3]
  231.                                 .FunctionOpcodeRecPtr;
  232.                             ProgramCounter = 0;
  233.                             /* increment function call depth counter */
  234.                             FuncCallDepth += 1;
  235.                             break;
  236.  
  237.                         case epErrorTrap:
  238.                             /*    -1            0    */
  239.                             /* <opcode> ^"<errorstring>" */
  240.                             PRNGCHK(CurrentProcedure,
  241.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  242.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  243.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  244.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  245.                                 "EvaluatePcode [epErrorTrap]:  expected scalar on stack"));
  246.                             if (Stack[StackPtr].Data.Integer == 0)
  247.                                 {
  248.                                     /* non-recoverable error -- abort */
  249.                                     AlertWarning("Nonrecoverable error trap encountered:  _",
  250.                                         CurrentProcedure[ProgramCounter + 0].ImmediateString);
  251.                                     ErrorCode = eEvalErrorTrapEncountered;
  252.                                     goto ExceptionPoint;
  253.                                 }
  254.                              else
  255.                                 {
  256.                                     if (AskYesNoCancel("Resumable error trap encountered:  _",
  257.                                         CurrentProcedure[ProgramCounter + 0].ImmediateString,
  258.                                         "Resume","Abort",NIL) != eYes)
  259.                                         {
  260.                                             ErrorCode = eEvalErrorTrapEncountered;
  261.                                             goto ExceptionPoint;
  262.                                         }
  263.                                 }
  264.                             /* leave argument on stack */
  265.                             ProgramCounter += 1;
  266.                             break;
  267.  
  268.                         case epBranchUnconditional:
  269.                             /*    -1            0    */
  270.                             /* <opcode> <branchoffset> */
  271.                             PRNGCHK(CurrentProcedure,
  272.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  273.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  274.                             ProgramCounter = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  275.                             break;
  276.  
  277.                         case epBranchIfZero:
  278.                             /*    -1            0    */
  279.                             /* <opcode> <branchoffset> */
  280.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  281.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  282.                                 "EvaluatePcode [epBranchIfZero]: bad stack element type"));
  283.                             if (Stack[StackPtr].Data.Integer == 0)
  284.                                 {
  285.                                     PRNGCHK(CurrentProcedure,
  286.                                         &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  287.                                         sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  288.                                     ProgramCounter = CurrentProcedure[ProgramCounter + 0]
  289.                                         .ImmediateInteger;
  290.                                 }
  291.                              else
  292.                                 {
  293.                                     ProgramCounter += 1;
  294.                                 }
  295.                             StackPtr -= 1;
  296.                             break;
  297.  
  298.                         case epBranchIfNotZero:
  299.                             /*    -1            0    */
  300.                             /* <opcode> <branchoffset> */
  301.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  302.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  303.                                 "EvaluatePcode [epBranchIfNotZero]: bad stack element type"));
  304.                             if (Stack[StackPtr].Data.Integer != 0)
  305.                                 {
  306.                                     PRNGCHK(CurrentProcedure,
  307.                                         &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  308.                                         sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  309.                                     ProgramCounter = CurrentProcedure[ProgramCounter + 0]
  310.                                         .ImmediateInteger;
  311.                                 }
  312.                              else
  313.                                 {
  314.                                     ProgramCounter += 1;
  315.                                 }
  316.                             StackPtr -= 1;
  317.                             break;
  318.  
  319.                         case epReturnFromSubroutine:
  320.                             /* - pop return address from top of stack */
  321.                             if (FuncCallDepth == 0)
  322.                                 {
  323.                                     /* if we are returning from root, then it's the end */
  324.                                     goto TotallyDonePoint;
  325.                                 }
  326.                             FuncCallDepth -= 1;
  327.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  328.                             ERROR((Stack[StackPtr].ElementType != esReturnAddress),PRERR(ForceAbort,
  329.                                 "EvaluatePcode [epReturnFromSubroutine]: Stack[0] is not a return address"));
  330.                             ProgramCounter = Stack[StackPtr].Data.ReturnAddress.Index;
  331.                             CheckPtrExistence(Stack[StackPtr].Data.ReturnAddress.Procedure);
  332.                             CurrentProcedure = Stack[StackPtr].Data.ReturnAddress.Procedure;
  333.                             EXECUTE(Stack[StackPtr].ElementType = esScalar;)
  334.                             StackPtr -= 1;
  335.                             break;
  336.  
  337.                         /* arithmetic operations */
  338.                         /* the right hand argument for binary operators is on top of stack */
  339.                         case epOperationFixedEqual:
  340.                         case epOperationIntegerEqual:
  341.                         case epOperationBooleanEqual:
  342.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  343.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  344.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  345.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  346.                                 ,PRERR(ForceAbort,
  347.                                 "EvaluatePcode [epOperationIntegerEqual]: bad stack element type"));
  348.                             Stack[StackPtr - 1].Data.Integer =
  349.                                 Stack[StackPtr - 1].Data.Integer == Stack[StackPtr].Data.Integer;
  350.                             StackPtr -= 1;
  351.                             break;
  352.                         case epOperationFixedNotEqual:
  353.                         case epOperationIntegerNotEqual:
  354.                         case epOperationBooleanNotEqual:
  355.                         case epOperationBooleanXor:
  356.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  357.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  358.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  359.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  360.                                 ,PRERR(ForceAbort,
  361.                                 "EvaluatePcode [epOperationIntegerNotEqual]: bad stack element type"));
  362.                             Stack[StackPtr - 1].Data.Integer =
  363.                                 Stack[StackPtr - 1].Data.Integer != Stack[StackPtr].Data.Integer;
  364.                             StackPtr -= 1;
  365.                             break;
  366.                         case epOperationIntegerXor:
  367.                         case epOperationFixedXor:
  368.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  369.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  370.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  371.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  372.                                 ,PRERR(ForceAbort,
  373.                                 "EvaluatePcode [epOperationIntegerXor]: bad stack element type"));
  374.                             Stack[StackPtr - 1].Data.Integer =
  375.                                 Stack[StackPtr - 1].Data.Integer ^ Stack[StackPtr].Data.Integer;
  376.                             StackPtr -= 1;
  377.                             break;
  378.                         case epOperationBooleanAnd:
  379.                         case epOperationIntegerAnd:
  380.                         case epOperationFixedAnd:
  381.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  382.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  383.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  384.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  385.                                 ,PRERR(ForceAbort,
  386.                                 "EvaluatePcode [epOperationIntegerAnd]: bad stack element type"));
  387.                             Stack[StackPtr - 1].Data.Integer =
  388.                                 Stack[StackPtr - 1].Data.Integer & Stack[StackPtr].Data.Integer;
  389.                                 /* note:  bitwise and! */
  390.                             StackPtr -= 1;
  391.                             break;
  392.                         case epOperationBooleanOr:
  393.                         case epOperationIntegerOr:
  394.                         case epOperationFixedOr:
  395.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  396.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  397.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  398.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  399.                                 ,PRERR(ForceAbort,
  400.                                 "EvaluatePcode [epOperationIntegerOr]: bad stack element type"));
  401.                             Stack[StackPtr - 1].Data.Integer =
  402.                                 Stack[StackPtr - 1].Data.Integer | Stack[StackPtr].Data.Integer;
  403.                                 /* note:  bitwise or! */
  404.                             StackPtr -= 1;
  405.                             break;
  406.                         case epOperationBooleanNot:
  407.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  408.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  409.                                 ,PRERR(ForceAbort,
  410.                                 "EvaluatePcode [epOperationBooleanNot]: bad stack element type"));
  411.                             Stack[StackPtr].Data.Integer = !Stack[StackPtr].Data.Integer;
  412.                             break;
  413.                         case epOperationIntegerNot:
  414.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  415.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  416.                                 ,PRERR(ForceAbort,
  417.                                 "EvaluatePcode [epOperationIntegerNot]: bad stack element type"));
  418.                             Stack[StackPtr].Data.Integer = ~Stack[StackPtr].Data.Integer;
  419.                             break;
  420.                         case epOperationBooleanToInteger:
  421.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  422.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  423.                                 ,PRERR(ForceAbort,
  424.                                 "EvaluatePcode [epOperationBooleanToInteger]: bad stack element type"));
  425.                             break;
  426.                         case epOperationTestFixedNegative:
  427.                         case epOperationTestIntegerNegative:
  428.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  429.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  430.                                 ,PRERR(ForceAbort,
  431.                                 "EvaluatePcode [epOperationTestIntegerNegative]: bad stack element type"));
  432.                             Stack[StackPtr].Data.Integer = (Stack[StackPtr].Data.Integer < 0);
  433.                             break;
  434.                         case epOperationTestFloatNegative:
  435.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  436.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  437.                                 ,PRERR(ForceAbort,
  438.                                 "EvaluatePcode [epOperationTestFloatNegative]: bad stack element type"));
  439.                             Stack[StackPtr].Data.Integer = (Stack[StackPtr].Data.Float < 0);
  440.                             break;
  441.                         case epOperationTestDoubleNegative:
  442.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  443.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  444.                                 ,PRERR(ForceAbort,
  445.                                 "EvaluatePcode [epOperationTestDoubleNegative]: bad stack element type"));
  446.                             Stack[StackPtr].Data.Integer = (Stack[StackPtr].Data.Double < 0);
  447.                             break;
  448.                         case epOperationGetSignFixed:
  449.                         case epOperationGetSignInteger:
  450.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  451.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  452.                                 ,PRERR(ForceAbort,
  453.                                 "EvaluatePcode [epOperationGetSignInteger]: bad stack element type"));
  454.                             if (Stack[StackPtr].Data.Integer < 0)
  455.                                 {
  456.                                     Stack[StackPtr].Data.Integer = -1;
  457.                                 }
  458.                             else if (Stack[StackPtr].Data.Integer > 0)
  459.                                 {
  460.                                     Stack[StackPtr].Data.Integer = 1;
  461.                                 }
  462.                             else
  463.                                 {
  464.                                     Stack[StackPtr].Data.Integer = 0;
  465.                                 }
  466.                             break;
  467.                         case epOperationGetSignFloat:
  468.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  469.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  470.                                 ,PRERR(ForceAbort,
  471.                                 "EvaluatePcode [epOperationGetSignFloat]: bad stack element type"));
  472.                             if (Stack[StackPtr].Data.Float < 0)
  473.                                 {
  474.                                     Stack[StackPtr].Data.Integer = -1;
  475.                                 }
  476.                             else if (Stack[StackPtr].Data.Float > 0)
  477.                                 {
  478.                                     Stack[StackPtr].Data.Integer = 1;
  479.                                 }
  480.                             else
  481.                                 {
  482.                                     Stack[StackPtr].Data.Integer = 0;
  483.                                 }
  484.                             break;
  485.                         case epOperationGetSignDouble:
  486.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  487.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  488.                                 ,PRERR(ForceAbort,
  489.                                 "EvaluatePcode [epOperationGetSignFloat]: bad stack element type"));
  490.                             if (Stack[StackPtr].Data.Double < 0)
  491.                                 {
  492.                                     Stack[StackPtr].Data.Integer = -1;
  493.                                 }
  494.                             else if (Stack[StackPtr].Data.Double > 0)
  495.                                 {
  496.                                     Stack[StackPtr].Data.Integer = 1;
  497.                                 }
  498.                             else
  499.                                 {
  500.                                     Stack[StackPtr].Data.Integer = 0;
  501.                                 }
  502.                             break;
  503.                         case epOperationIntegerToFloat:
  504.                         case epOperationBooleanToFloat:
  505.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  506.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  507.                                 ,PRERR(ForceAbort,
  508.                                 "EvaluatePcode [epOperationIntegerToFloat]: bad stack element type"));
  509.                             Stack[StackPtr].Data.Float = Stack[StackPtr].Data.Integer;
  510.                             break;
  511.                         case epOperationIntegerToDouble:
  512.                         case epOperationBooleanToDouble:
  513.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  514.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  515.                                 ,PRERR(ForceAbort,
  516.                                 "EvaluatePcode [epOperationIntegerToDouble]: bad stack element type"));
  517.                             Stack[StackPtr].Data.Double = Stack[StackPtr].Data.Integer;
  518.                             break;
  519.                         case epOperationIntegerToFixed:
  520.                         case epOperationBooleanToFixed:
  521.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  522.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  523.                                 ,PRERR(ForceAbort,
  524.                                 "EvaluatePcode [epOperationIntegerToFixed]: bad stack element type"));
  525.                             Stack[StackPtr].Data.Integer = int2largefixed(Stack[StackPtr].Data.Integer);
  526.                             break;
  527.                         case epOperationFixedNegation:
  528.                         case epOperationIntegerNegation:
  529.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  530.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  531.                                 ,PRERR(ForceAbort,
  532.                                 "EvaluatePcode [epOperationIntegerNegation]: bad stack element type"));
  533.                             Stack[StackPtr].Data.Integer = - Stack[StackPtr].Data.Integer;
  534.                             break;
  535.                         case epOperationFixedAdd:
  536.                         case epOperationIntegerAdd:
  537.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  538.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  539.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  540.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  541.                                 ,PRERR(ForceAbort,
  542.                                 "EvaluatePcode [epOperationIntegerAdd]: bad stack element type"));
  543.                             Stack[StackPtr - 1].Data.Integer =
  544.                                 Stack[StackPtr - 1].Data.Integer + Stack[StackPtr].Data.Integer;
  545.                             StackPtr -= 1;
  546.                             break;
  547.                         case epOperationFixedSubtract:
  548.                         case epOperationIntegerSubtract:
  549.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  550.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  551.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  552.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  553.                                 ,PRERR(ForceAbort,
  554.                                 "EvaluatePcode [epOperationIntegerSubtract]: bad stack element type"));
  555.                             Stack[StackPtr - 1].Data.Integer =
  556.                                 Stack[StackPtr - 1].Data.Integer - Stack[StackPtr].Data.Integer;
  557.                             StackPtr -= 1;
  558.                             break;
  559.                         case epOperationIntegerMultiply:
  560.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  561.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  562.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  563.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  564.                                 ,PRERR(ForceAbort,
  565.                                 "EvaluatePcode [epOperationIntegerMultiply]: bad stack element type"));
  566.                             Stack[StackPtr - 1].Data.Integer =
  567.                                 Stack[StackPtr - 1].Data.Integer * Stack[StackPtr].Data.Integer;
  568.                             StackPtr -= 1;
  569.                             break;
  570.                         case epOperationIntegerDivide:
  571.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  572.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  573.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  574.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  575.                                 ,PRERR(ForceAbort,
  576.                                 "EvaluatePcode [epOperationIntegerDivide]: bad stack element type"));
  577.                             if (Stack[StackPtr].Data.Integer == 0)
  578.                                 {
  579.                                     ErrorCode = eEvalDivideByZero;
  580.                                     goto ExceptionPoint;
  581.                                 }
  582.                             Stack[StackPtr - 1].Data.Integer =
  583.                                 Stack[StackPtr - 1].Data.Integer / Stack[StackPtr].Data.Integer;
  584.                             StackPtr -= 1;
  585.                             break;
  586.                         case epOperationIntegerImpreciseDivide:
  587.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  588.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  589.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  590.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  591.                                 ,PRERR(ForceAbort,
  592.                                 "EvaluatePcode [epOperationIntegerImpreciseDivide]: bad stack element type"));
  593.                             if (Stack[StackPtr].Data.Integer == 0)
  594.                                 {
  595.                                     ErrorCode = eEvalDivideByZero;
  596.                                     goto ExceptionPoint;
  597.                                 }
  598.                             Stack[StackPtr - 1].Data.Double = (double)Stack[StackPtr - 1].Data.Integer
  599.                                 / (double)Stack[StackPtr].Data.Integer;
  600.                             StackPtr -= 1;
  601.                             break;
  602.                         case epOperationIntegerModulo:
  603.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  604.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  605.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  606.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  607.                                 ,PRERR(ForceAbort,
  608.                                 "EvaluatePcode [epOperationIntegerModulo]: bad stack element type"));
  609.                             if (Stack[StackPtr].Data.Integer == 0)
  610.                                 {
  611.                                     ErrorCode = eEvalDivideByZero;
  612.                                     goto ExceptionPoint;
  613.                                 }
  614.                             Stack[StackPtr - 1].Data.Integer =
  615.                                 Stack[StackPtr - 1].Data.Integer % Stack[StackPtr].Data.Integer;
  616.                             StackPtr -= 1;
  617.                             break;
  618.                         case epOperationFixedAbs:
  619.                         case epOperationIntegerAbs:
  620.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  621.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  622.                                 ,PRERR(ForceAbort,
  623.                                 "EvaluatePcode [epOperationIntegerAbs]: bad stack element type"));
  624.                             if (Stack[StackPtr].Data.Integer < 0)
  625.                                 {
  626.                                     Stack[StackPtr].Data.Integer = - Stack[StackPtr].Data.Integer;
  627.                                 }
  628.                             break;
  629.                         case epOperationFixedShiftLeft:
  630.                         case epOperationIntegerShiftLeft:
  631.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  632.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  633.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  634.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  635.                                 ,PRERR(ForceAbort,
  636.                                 "EvaluatePcode [epOperationIntegerShiftLeft]: bad stack element type"));
  637.                             Stack[StackPtr - 1].Data.Integer =
  638.                                 Stack[StackPtr - 1].Data.Integer << Stack[StackPtr].Data.Integer;
  639.                             StackPtr -= 1;
  640.                             break;
  641.                         case epOperationFixedShiftRight:
  642.                         case epOperationIntegerShiftRight:
  643.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  644.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  645.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  646.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  647.                                 ,PRERR(ForceAbort,
  648.                                 "EvaluatePcode [epOperationIntegerShiftRight]: bad stack element type"));
  649.                             Stack[StackPtr - 1].Data.Integer =
  650.                                 Stack[StackPtr - 1].Data.Integer / (1L << Stack[StackPtr].Data.Integer);
  651.                             StackPtr -= 1;
  652.                             break;
  653.                         case epOperationFixedGreaterThan:
  654.                         case epOperationIntegerGreaterThan:
  655.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  656.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  657.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  658.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  659.                                 ,PRERR(ForceAbort,
  660.                                 "EvaluatePcode [epOperationIntegerGreaterThan]: bad stack element type"));
  661.                             Stack[StackPtr - 1].Data.Integer =
  662.                                 Stack[StackPtr - 1].Data.Integer > Stack[StackPtr].Data.Integer;
  663.                             StackPtr -= 1;
  664.                             break;
  665.                         case epOperationFixedLessThan:
  666.                         case epOperationIntegerLessThan:
  667.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  668.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  669.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  670.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  671.                                 ,PRERR(ForceAbort,
  672.                                 "EvaluatePcode [epOperationIntegerLessThan]: bad stack element type"));
  673.                             Stack[StackPtr - 1].Data.Integer =
  674.                                 Stack[StackPtr - 1].Data.Integer < Stack[StackPtr].Data.Integer;
  675.                             StackPtr -= 1;
  676.                             break;
  677.                         case epOperationFixedGreaterThanOrEqual:
  678.                         case epOperationIntegerGreaterThanOrEqual:
  679.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  680.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  681.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  682.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  683.                                 ,PRERR(ForceAbort,
  684.                                 "EvaluatePcode [epOperationIntegerGreaterThanOrEqual]: bad stack element type"));
  685.                             Stack[StackPtr - 1].Data.Integer =
  686.                                 Stack[StackPtr - 1].Data.Integer >= Stack[StackPtr].Data.Integer;
  687.                             StackPtr -= 1;
  688.                             break;
  689.                         case epOperationFixedLessThanOrEqual:
  690.                         case epOperationIntegerLessThanOrEqual:
  691.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  692.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  693.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  694.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  695.                                 ,PRERR(ForceAbort,
  696.                                 "EvaluatePcode [epOperationIntegerLessThanOrEqual]: bad stack element type"));
  697.                             Stack[StackPtr - 1].Data.Integer =
  698.                                 Stack[StackPtr - 1].Data.Integer <= Stack[StackPtr].Data.Integer;
  699.                             StackPtr -= 1;
  700.                             break;
  701.                         case epOperationFixedToBoolean:
  702.                         case epOperationIntegerToBoolean:
  703.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  704.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  705.                                 "EvaluatePcode [epOperationIntegerToBoolean]: bad stack element type"));
  706.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Integer != 0;
  707.                             break;
  708.                         case epOperationFloatAdd:
  709.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  710.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  711.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  712.                                 ,PRERR(ForceAbort,
  713.                                 "EvaluatePcode [epOperationFloatAdd]: bad stack element type"));
  714.                             Stack[StackPtr - 1].Data.Float =
  715.                                 Stack[StackPtr - 1].Data.Float + Stack[StackPtr].Data.Float;
  716.                             StackPtr -= 1;
  717.                             break;
  718.                         case epOperationFloatSubtract:
  719.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  720.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  721.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  722.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  723.                                 ,PRERR(ForceAbort,
  724.                                 "EvaluatePcode [epOperationFloatSubtract]: bad stack element type"));
  725.                             Stack[StackPtr - 1].Data.Float =
  726.                                 Stack[StackPtr - 1].Data.Float - Stack[StackPtr].Data.Float;
  727.                             StackPtr -= 1;
  728.                             break;
  729.                         case epOperationFloatNegation:
  730.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  731.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  732.                                 "EvaluatePcode [epOperationFloatNegation]: bad stack element type"));
  733.                             Stack[StackPtr].Data.Float = - Stack[StackPtr].Data.Float;
  734.                             break;
  735.                         case epOperationFloatMultiply:
  736.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  737.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  738.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  739.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  740.                                 ,PRERR(ForceAbort,
  741.                                 "EvaluatePcode [epOperationFloatMultiply]: bad stack element type"));
  742.                             Stack[StackPtr - 1].Data.Float =
  743.                                 Stack[StackPtr - 1].Data.Float * Stack[StackPtr].Data.Float;
  744.                             StackPtr -= 1;
  745.                             break;
  746.                         case epOperationFloatDivide:
  747.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  748.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  749.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  750.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  751.                                 ,PRERR(ForceAbort,
  752.                                 "EvaluatePcode [epOperationFloatDivide]: bad stack element type"));
  753.                             Stack[StackPtr - 1].Data.Float =
  754.                                 Stack[StackPtr - 1].Data.Float / Stack[StackPtr].Data.Float;
  755.                             StackPtr -= 1;
  756.                             break;
  757.                         case epOperationFloatShiftLeft:
  758.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  759.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  760.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  761.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  762.                                 ,PRERR(ForceAbort,
  763.                                 "EvaluatePcode [epOperationFloatShiftLeft]: bad stack element type"));
  764.                             Stack[StackPtr - 1].Data.Float =
  765.                                 Stack[StackPtr - 1].Data.Float * FPOWER(2,Stack[StackPtr].Data.Integer);
  766.                             StackPtr -= 1;
  767.                             break;
  768.                         case epOperationFloatShiftRight:
  769.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  770.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  771.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  772.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  773.                                 ,PRERR(ForceAbort,
  774.                                 "EvaluatePcode [epOperationFloatShiftRight]: bad stack element type"));
  775.                             Stack[StackPtr - 1].Data.Float =
  776.                                 Stack[StackPtr - 1].Data.Float * FPOWER(2,-Stack[StackPtr].Data.Integer);
  777.                             StackPtr -= 1;
  778.                             break;
  779.                         case epOperationFloatGreaterThan:
  780.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  781.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  782.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  783.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  784.                                 ,PRERR(ForceAbort,
  785.                                 "EvaluatePcode [epOperationFloatGreaterThan]: bad stack element type"));
  786.                             Stack[StackPtr - 1].Data.Integer =
  787.                                 Stack[StackPtr - 1].Data.Float > Stack[StackPtr].Data.Float;
  788.                             StackPtr -= 1;
  789.                             break;
  790.                         case epOperationFloatLessThan:
  791.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  792.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  793.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  794.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  795.                                 ,PRERR(ForceAbort,
  796.                                 "EvaluatePcode [epOperationFloatLessThan]: bad stack element type"));
  797.                             Stack[StackPtr - 1].Data.Integer =
  798.                                 Stack[StackPtr - 1].Data.Float < Stack[StackPtr].Data.Float;
  799.                             StackPtr -= 1;
  800.                             break;
  801.                         case epOperationFloatGreaterThanOrEqual:
  802.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  803.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  804.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  805.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  806.                                 ,PRERR(ForceAbort,
  807.                                 "EvaluatePcode [epOperationFloatGreaterThanOrEqual]: bad stack element type"));
  808.                             Stack[StackPtr - 1].Data.Integer =
  809.                                 Stack[StackPtr - 1].Data.Float >= Stack[StackPtr].Data.Float;
  810.                             StackPtr -= 1;
  811.                             break;
  812.                         case epOperationFloatLessThanOrEqual:
  813.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  814.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  815.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  816.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  817.                                 ,PRERR(ForceAbort,
  818.                                 "EvaluatePcode [epOperationFloatLessThanOrEqual]: bad stack element type"));
  819.                             Stack[StackPtr - 1].Data.Integer =
  820.                                 Stack[StackPtr - 1].Data.Float <= Stack[StackPtr].Data.Float;
  821.                             StackPtr -= 1;
  822.                             break;
  823.                         case epOperationFloatEqual:
  824.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  825.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  826.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  827.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  828.                                 ,PRERR(ForceAbort,
  829.                                 "EvaluatePcode [epOperationFloatEqual]: bad stack element type"));
  830.                             Stack[StackPtr - 1].Data.Integer =
  831.                                 Stack[StackPtr - 1].Data.Float == Stack[StackPtr].Data.Float;
  832.                             StackPtr -= 1;
  833.                             break;
  834.                         case epOperationFloatNotEqual:
  835.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  836.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  837.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  838.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  839.                                 ,PRERR(ForceAbort,
  840.                                 "EvaluatePcode [epOperationFloatNotEqual]: bad stack element type"));
  841.                             Stack[StackPtr - 1].Data.Integer =
  842.                                 Stack[StackPtr - 1].Data.Float != Stack[StackPtr].Data.Float;
  843.                             StackPtr -= 1;
  844.                             break;
  845.                         case epOperationFloatAbs:
  846.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  847.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  848.                                 "EvaluatePcode [epOperationFloatAbs]: bad stack element type"));
  849.                             if (Stack[StackPtr].Data.Float < 0)
  850.                                 {
  851.                                     Stack[StackPtr].Data.Float = - Stack[StackPtr].Data.Float;
  852.                                 }
  853.                             break;
  854.                         case epOperationFloatToBoolean:
  855.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  856.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  857.                                 "EvaluatePcode [epOperationFloatToBoolean]: bad stack element type"));
  858.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Float != 0;
  859.                             break;
  860.                         case epOperationFloatToInteger:
  861.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  862.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  863.                                 "EvaluatePcode [epOperationFloatToInteger]: bad stack element type"));
  864.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Float;
  865.                             break;
  866.                         case epOperationFloatToDouble:
  867.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  868.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  869.                                 "EvaluatePcode [epOperationFloatToDouble]: bad stack element type"));
  870.                             Stack[StackPtr].Data.Double = Stack[StackPtr].Data.Float;
  871.                             break;
  872.                         case epOperationFloatToFixed:
  873.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  874.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  875.                                 "EvaluatePcode [epOperationFloatToFixed]: bad stack element type"));
  876.                             Stack[StackPtr].Data.Integer = double2largefixed(Stack[StackPtr].Data.Float);
  877.                             break;
  878.                         case epOperationDoubleAdd:
  879.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  880.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  881.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  882.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  883.                                 ,PRERR(ForceAbort,
  884.                                 "EvaluatePcode [epOperationDoubleAdd]: bad stack element type"));
  885.                             Stack[StackPtr - 1].Data.Double =
  886.                                 Stack[StackPtr - 1].Data.Double + Stack[StackPtr].Data.Double;
  887.                             StackPtr -= 1;
  888.                             break;
  889.                         case epOperationDoubleSubtract:
  890.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  891.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  892.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  893.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  894.                                 ,PRERR(ForceAbort,
  895.                                 "EvaluatePcode [epOperationDoubleSubtract]: bad stack element type"));
  896.                             Stack[StackPtr - 1].Data.Double =
  897.                                 Stack[StackPtr - 1].Data.Double - Stack[StackPtr].Data.Double;
  898.                             StackPtr -= 1;
  899.                             break;
  900.                         case epOperationDoubleNegation:
  901.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  902.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  903.                                 ,PRERR(ForceAbort,
  904.                                 "EvaluatePcode [epOperationDoubleNegation]: bad stack element type"));
  905.                             Stack[StackPtr].Data.Double = - Stack[StackPtr].Data.Double;
  906.                             break;
  907.                         case epOperationDoubleMultiply:
  908.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  909.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  910.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  911.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  912.                                 ,PRERR(ForceAbort,
  913.                                 "EvaluatePcode [epOperationDoubleMultiply]: bad stack element type"));
  914.                             Stack[StackPtr - 1].Data.Double =
  915.                                 Stack[StackPtr - 1].Data.Double * Stack[StackPtr].Data.Double;
  916.                             StackPtr -= 1;
  917.                             break;
  918.                         case epOperationDoubleDivide:
  919.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  920.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  921.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  922.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  923.                                 ,PRERR(ForceAbort,
  924.                                 "EvaluatePcode [epOperationDoubleDivide]: bad stack element type"));
  925.                             Stack[StackPtr - 1].Data.Double =
  926.                                 Stack[StackPtr - 1].Data.Double / Stack[StackPtr].Data.Double;
  927.                             StackPtr -= 1;
  928.                             break;
  929.                         case epOperationDoubleShiftLeft:
  930.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  931.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  932.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  933.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  934.                                 ,PRERR(ForceAbort,
  935.                                 "EvaluatePcode [epOperationDoubleShiftLeft]: bad stack element type"));
  936.                             Stack[StackPtr - 1].Data.Double =
  937.                                 Stack[StackPtr - 1].Data.Double * DPOWER(2,Stack[StackPtr].Data.Integer);
  938.                             StackPtr -= 1;
  939.                             break;
  940.                         case epOperationDoubleShiftRight:
  941.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  942.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  943.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  944.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  945.                                 ,PRERR(ForceAbort,
  946.                                 "EvaluatePcode [epOperationDoubleShiftLeft]: bad stack element type"));
  947.                             Stack[StackPtr - 1].Data.Double =
  948.                                 Stack[StackPtr - 1].Data.Double * DPOWER(2,-Stack[StackPtr].Data.Integer);
  949.                             StackPtr -= 1;
  950.                             break;
  951.                         case epOperationDoubleGreaterThan:
  952.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  953.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  954.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  955.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  956.                                 ,PRERR(ForceAbort,
  957.                                 "EvaluatePcode [epOperationDoubleGreaterThan]: bad stack element type"));
  958.                             Stack[StackPtr - 1].Data.Integer =
  959.                                 Stack[StackPtr - 1].Data.Double > Stack[StackPtr].Data.Double;
  960.                             StackPtr -= 1;
  961.                             break;
  962.                         case epOperationDoubleLessThan:
  963.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  964.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  965.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  966.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  967.                                 ,PRERR(ForceAbort,
  968.                                 "EvaluatePcode [epOperationDoubleLessThan]: bad stack element type"));
  969.                             Stack[StackPtr - 1].Data.Integer =
  970.                                 Stack[StackPtr - 1].Data.Double < Stack[StackPtr].Data.Double;
  971.                             StackPtr -= 1;
  972.                             break;
  973.                         case epOperationDoubleGreaterThanOrEqual:
  974.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  975.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  976.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  977.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  978.                                 ,PRERR(ForceAbort,
  979.                                 "EvaluatePcode [epOperationDoubleGreaterThanOrEqual]: bad stack element type"));
  980.                             Stack[StackPtr - 1].Data.Integer =
  981.                                 Stack[StackPtr - 1].Data.Double >= Stack[StackPtr].Data.Double;
  982.                             StackPtr -= 1;
  983.                             break;
  984.                         case epOperationDoubleLessThanOrEqual:
  985.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  986.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  987.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  988.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  989.                                 ,PRERR(ForceAbort,
  990.                                 "EvaluatePcode [epOperationDoubleLessThanOrEqual]: bad stack element type"));
  991.                             Stack[StackPtr - 1].Data.Integer =
  992.                                 Stack[StackPtr - 1].Data.Double <= Stack[StackPtr].Data.Double;
  993.                             StackPtr -= 1;
  994.                             break;
  995.                         case epOperationDoubleEqual:
  996.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  997.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  998.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  999.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1000.                                 ,PRERR(ForceAbort,
  1001.                                 "EvaluatePcode [epOperationDoubleEqual]: bad stack element type"));
  1002.                             Stack[StackPtr - 1].Data.Integer =
  1003.                                 Stack[StackPtr - 1].Data.Double == Stack[StackPtr].Data.Double;
  1004.                             StackPtr -= 1;
  1005.                             break;
  1006.                         case epOperationDoubleNotEqual:
  1007.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1008.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1009.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1010.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1011.                                 ,PRERR(ForceAbort,
  1012.                                 "EvaluatePcode [epOperationDoubleNotEqual]: bad stack element type"));
  1013.                             Stack[StackPtr - 1].Data.Integer =
  1014.                                 Stack[StackPtr - 1].Data.Double != Stack[StackPtr].Data.Double;
  1015.                             StackPtr -= 1;
  1016.                             break;
  1017.                         case epOperationDoubleAbs:
  1018.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1019.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1020.                                 "EvaluatePcode [epOperationDoubleAbs]: bad stack element type"));
  1021.                             if (Stack[StackPtr].Data.Double < 0)
  1022.                                 {
  1023.                                     Stack[StackPtr].Data.Double = - Stack[StackPtr].Data.Double;
  1024.                                 }
  1025.                             break;
  1026.                         case epOperationDoubleToBoolean:
  1027.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1028.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1029.                                 "EvaluatePcode [epOperationDoubleToBoolean]: bad stack element type"));
  1030.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Double != 0;
  1031.                             break;
  1032.                         case epOperationDoubleToInteger:
  1033.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1034.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1035.                                 "EvaluatePcode [epOperationDoubleToInteger]: bad stack element type"));
  1036.                             Stack[StackPtr].Data.Integer = Stack[StackPtr].Data.Double;
  1037.                             break;
  1038.                         case epOperationDoubleToFloat:
  1039.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1040.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1041.                                 "EvaluatePcode [epOperationDoubleToFloat]: bad stack element type"));
  1042.                             Stack[StackPtr].Data.Float = Stack[StackPtr].Data.Double;
  1043.                             break;
  1044.                         case epOperationDoubleToFixed:
  1045.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1046.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1047.                                 "EvaluatePcode [epOperationDoubleToFixed]: bad stack element type"));
  1048.                             Stack[StackPtr].Data.Integer = double2largefixed(Stack[StackPtr].Data.Double);
  1049.                             break;
  1050.                         case epOperationDoubleSin:
  1051.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1052.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1053.                                 "EvaluatePcode [epOperationDoubleSin]: bad stack element type"));
  1054.                             Stack[StackPtr].Data.Double = DSIN(Stack[StackPtr].Data.Double);
  1055.                             break;
  1056.                         case epOperationDoubleCos:
  1057.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1058.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1059.                                 "EvaluatePcode [epOperationDoubleCos]: bad stack element type"));
  1060.                             Stack[StackPtr].Data.Double = DCOS(Stack[StackPtr].Data.Double);
  1061.                             break;
  1062.                         case epOperationDoubleTan:
  1063.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1064.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1065.                                 "EvaluatePcode [epOperationDoubleTan]: bad stack element type"));
  1066.                             Stack[StackPtr].Data.Double = DTAN(Stack[StackPtr].Data.Double);
  1067.                             break;
  1068.                         case epOperationDoubleAsin:
  1069.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1070.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1071.                                 "EvaluatePcode [epOperationDoubleAsin]: bad stack element type"));
  1072.                             Stack[StackPtr].Data.Double = DASIN(Stack[StackPtr].Data.Double);
  1073.                             break;
  1074.                         case epOperationDoubleAcos:
  1075.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1076.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1077.                                 "EvaluatePcode [epOperationDoubleAcos]: bad stack element type"));
  1078.                             Stack[StackPtr].Data.Double = DACOS(Stack[StackPtr].Data.Double);
  1079.                             break;
  1080.                         case epOperationDoubleAtan:
  1081.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1082.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1083.                                 "EvaluatePcode [epOperationDoubleAtan]: bad stack element type"));
  1084.                             Stack[StackPtr].Data.Double = DATAN(Stack[StackPtr].Data.Double);
  1085.                             break;
  1086.                         case epOperationDoubleLn:
  1087.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1088.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1089.                                 "EvaluatePcode [epOperationDoubleLn]: bad stack element type"));
  1090.                             Stack[StackPtr].Data.Double = DLN(Stack[StackPtr].Data.Double);
  1091.                             break;
  1092.                         case epOperationDoubleExp:
  1093.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1094.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1095.                                 "EvaluatePcode [epOperationDoubleExp]: bad stack element type"));
  1096.                             Stack[StackPtr].Data.Double = DEXP(Stack[StackPtr].Data.Double);
  1097.                             break;
  1098.                         case epOperationDoubleSqrt:
  1099.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1100.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1101.                                 "EvaluatePcode [epOperationDoubleSqrt]: bad stack element type"));
  1102.                             Stack[StackPtr].Data.Double = DSQRT(Stack[StackPtr].Data.Double);
  1103.                             break;
  1104.                         case epOperationDoubleSqr:
  1105.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1106.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1107.                                 "EvaluatePcode [epOperationDoubleSqr]: bad stack element type"));
  1108.                             Stack[StackPtr].Data.Double = Stack[StackPtr].Data.Double
  1109.                                 * Stack[StackPtr].Data.Double;
  1110.                             break;
  1111.                         case epOperationDoublePower:
  1112.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1113.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1114.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1115.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1116.                                 ,PRERR(ForceAbort,
  1117.                                 "EvaluatePcode [epOperationDoublePower]: bad stack element type"));
  1118.                             Stack[StackPtr - 1].Data.Double =
  1119.                                 DPOWER(Stack[StackPtr - 1].Data.Double,Stack[StackPtr].Data.Double);
  1120.                             StackPtr -= 1;
  1121.                             break;
  1122.                         case epOperationFixedMultiply:
  1123.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1124.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1125.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1126.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1127.                                 ,PRERR(ForceAbort,
  1128.                                 "EvaluatePcode [epOperationFixedMultiply]: bad stack element type"));
  1129.                             Stack[StackPtr - 1].Data.Integer = largefixedmult(
  1130.                                 Stack[StackPtr - 1].Data.Integer,Stack[StackPtr].Data.Integer);
  1131.                             StackPtr -= 1;
  1132.                             break;
  1133.                         case epOperationFixedDivide:
  1134.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1135.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1136.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  1137.                                 || (Stack[StackPtr - 1].ElementType != esScalar)
  1138.                                 ,PRERR(ForceAbort,
  1139.                                 "EvaluatePcode [epOperationFixedDivide]: bad stack element type"));
  1140.                             Stack[StackPtr - 1].Data.Integer = double2largefixed(
  1141.                                 largefixed2double(Stack[StackPtr - 1].Data.Integer)
  1142.                                 / largefixed2double(Stack[StackPtr].Data.Integer));
  1143.                             StackPtr -= 1;
  1144.                             break;
  1145.                         case epOperationFixedToInteger:
  1146.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1147.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1148.                                 "EvaluatePcode [epOperationFixedToInteger]: bad stack element type"));
  1149.                             Stack[StackPtr].Data.Integer = largefixed2int(Stack[StackPtr].Data.Integer);
  1150.                             break;
  1151.                         case epOperationFixedToFloat:
  1152.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1153.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1154.                                 "EvaluatePcode [epOperationFixedToFloat]: bad stack element type"));
  1155.                             Stack[StackPtr].Data.Float = largefixed2double(Stack[StackPtr].Data.Integer);
  1156.                             break;
  1157.                         case epOperationFixedToDouble:
  1158.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1159.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1160.                                 "EvaluatePcode [epOperationFixedToDouble]: bad stack element type"));
  1161.                             Stack[StackPtr].Data.Double = largefixed2double(Stack[StackPtr].Data.Integer);
  1162.                             break;
  1163.  
  1164.                         /* other conversion operations */
  1165.                         case epOperationBooleanToIntegerBuried:  /* <opcode> <stackindex> */
  1166.                             /*    -1            0    */
  1167.                             /* <opcode> <branchoffset> */
  1168.                             PRNGCHK(CurrentProcedure,
  1169.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1170.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1171.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1172.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1173.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1174.                                 "EvaluatePcode [epOperationBooleanToIntegerBuried]:  not a scalar"));
  1175.                             ProgramCounter += 1;
  1176.                             break;
  1177.                         case epOperationIntegerToFloatBuried:
  1178.                         case epOperationBooleanToFloatBuried:
  1179.                             /*    -1            0    */
  1180.                             /* <opcode> <branchoffset> */
  1181.                             PRNGCHK(CurrentProcedure,
  1182.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1183.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1184.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1185.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1186.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1187.                                 "EvaluatePcode [epOperationIntegerToFloatBuried]:  not a scalar"));
  1188.                             Stack[Index].Data.Float = Stack[Index].Data.Integer;
  1189.                             ProgramCounter += 1;
  1190.                             break;
  1191.                         case epOperationIntegerToDoubleBuried:
  1192.                         case epOperationBooleanToDoubleBuried:
  1193.                             /*    -1            0    */
  1194.                             /* <opcode> <branchoffset> */
  1195.                             PRNGCHK(CurrentProcedure,
  1196.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1197.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1198.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1199.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1200.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1201.                                 "EvaluatePcode [epOperationIntegerToDoubleBuried]:  not a scalar"));
  1202.                             Stack[Index].Data.Double = Stack[Index].Data.Integer;
  1203.                             ProgramCounter += 1;
  1204.                             break;
  1205.                         case epOperationIntegerToFixedBuried:
  1206.                         case epOperationBooleanToFixedBuried:
  1207.                             /*    -1            0    */
  1208.                             /* <opcode> <branchoffset> */
  1209.                             PRNGCHK(CurrentProcedure,
  1210.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1211.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1212.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1213.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1214.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1215.                                 "EvaluatePcode [epOperationIntegerToFixedBuried]:  not a scalar"));
  1216.                             Stack[Index].Data.Integer = int2largefixed(Stack[Index].Data.Integer);
  1217.                             ProgramCounter += 1;
  1218.                             break;
  1219.                         case epOperationFixedToBooleanBuried:
  1220.                         case epOperationIntegerToBooleanBuried:
  1221.                             /*    -1            0    */
  1222.                             /* <opcode> <branchoffset> */
  1223.                             PRNGCHK(CurrentProcedure,
  1224.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1225.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1226.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1227.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1228.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1229.                                 "EvaluatePcode [epOperationIntegerToBooleanBuried]:  not a scalar"));
  1230.                             Stack[Index].Data.Integer = Stack[Index].Data.Integer != 0;
  1231.                             ProgramCounter += 1;
  1232.                             break;
  1233.                         case epOperationFloatToBooleanBuried:
  1234.                             /*    -1            0    */
  1235.                             /* <opcode> <branchoffset> */
  1236.                             PRNGCHK(CurrentProcedure,
  1237.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1238.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1239.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1240.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1241.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1242.                                 "EvaluatePcode [epOperationFloatToBooleanBuried]:  not a scalar"));
  1243.                             Stack[Index].Data.Integer = Stack[Index].Data.Float != 0;
  1244.                             ProgramCounter += 1;
  1245.                             break;
  1246.                         case epOperationFloatToIntegerBuried:
  1247.                             /*    -1            0    */
  1248.                             /* <opcode> <branchoffset> */
  1249.                             PRNGCHK(CurrentProcedure,
  1250.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1251.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1252.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1253.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1254.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1255.                                 "EvaluatePcode [epOperationFloatToIntegerBuried]:  not a scalar"));
  1256.                             Stack[Index].Data.Integer = Stack[Index].Data.Float;
  1257.                             ProgramCounter += 1;
  1258.                             break;
  1259.                         case epOperationFloatToDoubleBuried:
  1260.                             /*    -1            0    */
  1261.                             /* <opcode> <branchoffset> */
  1262.                             PRNGCHK(CurrentProcedure,
  1263.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1264.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1265.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1266.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1267.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1268.                                 "EvaluatePcode [epOperationFloatToDoubleBuried]:  not a scalar"));
  1269.                             Stack[Index].Data.Double = Stack[Index].Data.Float;
  1270.                             ProgramCounter += 1;
  1271.                             break;
  1272.                         case epOperationFloatToFixedBuried:
  1273.                             /*    -1            0    */
  1274.                             /* <opcode> <branchoffset> */
  1275.                             PRNGCHK(CurrentProcedure,
  1276.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1277.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1278.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1279.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1280.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1281.                                 "EvaluatePcode [epOperationFloatToFixedBuried]:  not a scalar"));
  1282.                             Stack[Index].Data.Integer = double2largefixed(Stack[Index].Data.Float);
  1283.                             ProgramCounter += 1;
  1284.                             break;
  1285.                         case epOperationDoubleToBooleanBuried:
  1286.                             /*    -1            0    */
  1287.                             /* <opcode> <branchoffset> */
  1288.                             PRNGCHK(CurrentProcedure,
  1289.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1290.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1291.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1292.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1293.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1294.                                 "EvaluatePcode [epOperationDoubleToBooleanBuried]:  not a scalar"));
  1295.                             Stack[Index].Data.Integer = Stack[Index].Data.Double != 0;
  1296.                             ProgramCounter += 1;
  1297.                             break;
  1298.                         case epOperationDoubleToIntegerBuried:
  1299.                             /*    -1            0    */
  1300.                             /* <opcode> <branchoffset> */
  1301.                             PRNGCHK(CurrentProcedure,
  1302.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1303.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1304.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1305.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1306.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1307.                                 "EvaluatePcode [epOperationDoubleToIntegerBuried]:  not a scalar"));
  1308.                             Stack[Index].Data.Integer = Stack[Index].Data.Double;
  1309.                             ProgramCounter += 1;
  1310.                             break;
  1311.                         case epOperationDoubleToFloatBuried:
  1312.                             /*    -1            0    */
  1313.                             /* <opcode> <branchoffset> */
  1314.                             PRNGCHK(CurrentProcedure,
  1315.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1316.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1317.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1318.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1319.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1320.                                 "EvaluatePcode [epOperationDoubleToFloatBuried]:  not a scalar"));
  1321.                             Stack[Index].Data.Float = Stack[Index].Data.Double;
  1322.                             ProgramCounter += 1;
  1323.                             break;
  1324.                         case epOperationDoubleToFixedBuried:
  1325.                             /*    -1            0    */
  1326.                             /* <opcode> <branchoffset> */
  1327.                             PRNGCHK(CurrentProcedure,
  1328.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1329.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1330.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1331.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1332.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1333.                                 "EvaluatePcode [epOperationDoubleToFixedBuried]:  not a scalar"));
  1334.                             Stack[Index].Data.Integer = double2largefixed(Stack[Index].Data.Double);
  1335.                             ProgramCounter += 1;
  1336.                             break;
  1337.                         case epOperationFixedToIntegerBuried:
  1338.                             /*    -1            0    */
  1339.                             /* <opcode> <branchoffset> */
  1340.                             PRNGCHK(CurrentProcedure,
  1341.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1342.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1343.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1344.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1345.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1346.                                 "EvaluatePcode [epOperationFixedToIntegerBuried]:  not a scalar"));
  1347.                             Stack[Index].Data.Integer = largefixed2int(Stack[Index].Data.Integer);
  1348.                             ProgramCounter += 1;
  1349.                             break;
  1350.                         case epOperationFixedToFloatBuried:
  1351.                             /*    -1            0    */
  1352.                             /* <opcode> <branchoffset> */
  1353.                             PRNGCHK(CurrentProcedure,
  1354.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1355.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1356.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1357.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1358.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1359.                                 "EvaluatePcode [epOperationFixedToFloatBuried]:  not a scalar"));
  1360.                             Stack[Index].Data.Float = largefixed2double(Stack[Index].Data.Integer);
  1361.                             ProgramCounter += 1;
  1362.                             break;
  1363.                         case epOperationFixedToDoubleBuried:
  1364.                             /*    -1            0    */
  1365.                             /* <opcode> <branchoffset> */
  1366.                             PRNGCHK(CurrentProcedure,
  1367.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1368.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1369.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1370.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1371.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1372.                                 "EvaluatePcode [epOperationFixedToDoubleBuried]:  not a scalar"));
  1373.                             Stack[Index].Data.Double = largefixed2double(Stack[Index].Data.Integer);
  1374.                             ProgramCounter += 1;
  1375.                             break;
  1376.  
  1377.                         /* array sizing stuff. */
  1378.                         case epGetBooleanArraySize:
  1379.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1380.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1381.                                 "EvaluatePcode [epGetBooleanArraySize]: bad stack element type"));
  1382.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  1383.                                 {
  1384.                                     ErrorCode = eEvalArrayDoesntExist;
  1385.                                     goto ExceptionPoint;
  1386.                                 }
  1387.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle);
  1388.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  1389.                             Index = PtrSize((char*)(Stack[StackPtr].Data.ArrayHandle->Array));
  1390.                             DisposeIfNotOnStack(Stack,StackPtr);
  1391.                             Stack[StackPtr].ElementType = esScalar;
  1392.                             Stack[StackPtr].Data.Integer = Index;
  1393.                             break;
  1394.                         case epGetIntegerArraySize:
  1395.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1396.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1397.                                 "EvaluatePcode [epGetIntegerArraySize]: bad stack element type"));
  1398.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  1399.                                 {
  1400.                                     ErrorCode = eEvalArrayDoesntExist;
  1401.                                     goto ExceptionPoint;
  1402.                                 }
  1403.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle);
  1404.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  1405.                             Index = PtrSize((char*)(Stack[StackPtr].Data.ArrayHandle->Array))
  1406.                                 / sizeof(long);
  1407.                             DisposeIfNotOnStack(Stack,StackPtr);
  1408.                             Stack[StackPtr].ElementType = esScalar;
  1409.                             Stack[StackPtr].Data.Integer = Index;
  1410.                             break;
  1411.                         case epGetFloatArraySize:
  1412.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1413.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1414.                                 "EvaluatePcode [epGetFloatArraySize]: bad stack element type"));
  1415.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  1416.                                 {
  1417.                                     ErrorCode = eEvalArrayDoesntExist;
  1418.                                     goto ExceptionPoint;
  1419.                                 }
  1420.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle);
  1421.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  1422.                             Index = PtrSize((char*)(Stack[StackPtr].Data.ArrayHandle->Array))
  1423.                                 / sizeof(float);
  1424.                             DisposeIfNotOnStack(Stack,StackPtr);
  1425.                             Stack[StackPtr].ElementType = esScalar;
  1426.                             Stack[StackPtr].Data.Integer = Index;
  1427.                             break;
  1428.                         case epGetDoubleArraySize:
  1429.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1430.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1431.                                 "EvaluatePcode [epGetDoubleArraySize]: bad stack element type"));
  1432.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  1433.                                 {
  1434.                                     ErrorCode = eEvalArrayDoesntExist;
  1435.                                     goto ExceptionPoint;
  1436.                                 }
  1437.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle);
  1438.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  1439.                             Index = PtrSize((char*)(Stack[StackPtr].Data.ArrayHandle->Array))
  1440.                                 / sizeof(double);
  1441.                             DisposeIfNotOnStack(Stack,StackPtr);
  1442.                             Stack[StackPtr].ElementType = esScalar;
  1443.                             Stack[StackPtr].Data.Integer = Index;
  1444.                             break;
  1445.                         case epGetFixedArraySize:
  1446.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1447.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1448.                                 "EvaluatePcode [epGetFixedArraySize]: bad stack element type"));
  1449.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  1450.                                 {
  1451.                                     ErrorCode = eEvalArrayDoesntExist;
  1452.                                     goto ExceptionPoint;
  1453.                                 }
  1454.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle);
  1455.                             CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  1456.                             Index = PtrSize((char*)(Stack[StackPtr].Data.ArrayHandle->Array))
  1457.                                 / sizeof(largefixedsigned);
  1458.                             DisposeIfNotOnStack(Stack,StackPtr);
  1459.                             Stack[StackPtr].ElementType = esScalar;
  1460.                             Stack[StackPtr].Data.Integer = Index;
  1461.                             break;
  1462.  
  1463.                         case epResizeBooleanArray2:
  1464.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1465.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1466.                                 "EvaluatePcode [epResizeBooleanArray]: bad stack element type"));
  1467.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1468.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1469.                                 "EvaluatePcode [epResizeBooleanArray2]:  array slot of wrong type"));
  1470.                             if (Stack[StackPtr].Data.Integer < 0)
  1471.                                 {
  1472.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1473.                                     goto ExceptionPoint;
  1474.                                 }
  1475.                             if (Stack[StackPtr - 1].Data.ArrayHandle != NIL)
  1476.                                 {
  1477.                                     void*                    OldReference;
  1478.                                     void*                    NewReference;
  1479.                                     long                    SizeDifference;
  1480.  
  1481.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  1482.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  1483.                                     OldReference = Stack[StackPtr - 1].Data.ArrayHandle->Array;
  1484.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1485.                                         - (PtrSize((char*)OldReference) / sizeof(char));
  1486.                                     NewReference = ResizePtr((char*)OldReference,
  1487.                                         Stack[StackPtr].Data.Integer);
  1488.                                     if (NewReference == NIL)
  1489.                                         {
  1490.                                             ErrorCode = eEvalOutOfMemory;
  1491.                                             goto ExceptionPoint;
  1492.                                         }
  1493.                                     /* now patch up the references */
  1494.                                     Stack[StackPtr - 1].Data.ArrayHandle->Array = NewReference;
  1495.                                     /* if we added to the array, then we have to zero those elements */
  1496.                                     if (SizeDifference > 0)
  1497.                                         {
  1498.                                             long                    Limit;
  1499.  
  1500.                                             Limit = Stack[StackPtr].Data.Integer;
  1501.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1502.                                                 {
  1503.                                                     PRNGCHK(NewReference,&(((char*)NewReference)[Index]),
  1504.                                                         sizeof(char));
  1505.                                                     ((char*)NewReference)[Index] = 0;
  1506.                                                 }
  1507.                                         }
  1508.                                 }
  1509.                              else
  1510.                                 {
  1511.                                     ErrorCode = eEvalArrayDoesntExist;
  1512.                                     goto ExceptionPoint;
  1513.                                 }
  1514.                             StackPtr -= 1;
  1515.                             break;
  1516.                         case epResizeIntegerArray2:
  1517.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1518.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1519.                                 "EvaluatePcode [epResizeIntegerArray]: bad stack element type"));
  1520.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1521.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1522.                                 "EvaluatePcode [epResizeIntegerArray]:  array slot of wrong type"));
  1523.                             if (Stack[StackPtr].Data.Integer < 0)
  1524.                                 {
  1525.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1526.                                     goto ExceptionPoint;
  1527.                                 }
  1528.                             if (Stack[StackPtr - 1].Data.ArrayHandle != NIL)
  1529.                                 {
  1530.                                     void*                    OldReference;
  1531.                                     void*                    NewReference;
  1532.                                     long                    SizeDifference;
  1533.  
  1534.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  1535.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  1536.                                     OldReference = Stack[StackPtr - 1].Data.ArrayHandle->Array;
  1537.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1538.                                         - (PtrSize((char*)OldReference) / sizeof(long));
  1539.                                     NewReference = ResizePtr((char*)OldReference,
  1540.                                         Stack[StackPtr].Data.Integer * sizeof(long));
  1541.                                     if (NewReference == NIL)
  1542.                                         {
  1543.                                             ErrorCode = eEvalOutOfMemory;
  1544.                                             goto ExceptionPoint;
  1545.                                         }
  1546.                                     /* now patch up the references */
  1547.                                     Stack[StackPtr - 1].Data.ArrayHandle->Array = NewReference;
  1548.                                     /* if we added to the array, then we have to zero those elements */
  1549.                                     if (SizeDifference > 0)
  1550.                                         {
  1551.                                             long                    Limit;
  1552.  
  1553.                                             Limit = Stack[StackPtr].Data.Integer;
  1554.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1555.                                                 {
  1556.                                                     PRNGCHK(NewReference,&(((long*)NewReference)[Index]),
  1557.                                                         sizeof(long));
  1558.                                                     ((long*)NewReference)[Index] = 0;
  1559.                                                 }
  1560.                                         }
  1561.                                 }
  1562.                              else
  1563.                                 {
  1564.                                     ErrorCode = eEvalArrayDoesntExist;
  1565.                                     goto ExceptionPoint;
  1566.                                 }
  1567.                             StackPtr -= 1;
  1568.                             break;
  1569.                         case epResizeFloatArray2:
  1570.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1571.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1572.                                 "EvaluatePcode [epResizeFloatArray]: bad stack element type"));
  1573.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1574.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1575.                                 "EvaluatePcode [epResizeFloatArray]:  array slot of wrong type"));
  1576.                             if (Stack[StackPtr].Data.Integer < 0)
  1577.                                 {
  1578.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1579.                                     goto ExceptionPoint;
  1580.                                 }
  1581.                             if (Stack[StackPtr - 1].Data.ArrayHandle != NIL)
  1582.                                 {
  1583.                                     void*                    OldReference;
  1584.                                     void*                    NewReference;
  1585.                                     long                    SizeDifference;
  1586.  
  1587.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  1588.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  1589.                                     OldReference = Stack[StackPtr - 1].Data.ArrayHandle->Array;
  1590.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1591.                                         - (PtrSize((char*)OldReference) / sizeof(float));
  1592.                                     NewReference = ResizePtr((char*)OldReference,
  1593.                                         Stack[StackPtr].Data.Integer * sizeof(float));
  1594.                                     if (NewReference == NIL)
  1595.                                         {
  1596.                                             ErrorCode = eEvalOutOfMemory;
  1597.                                             goto ExceptionPoint;
  1598.                                         }
  1599.                                     /* now patch up the references */
  1600.                                     Stack[StackPtr - 1].Data.ArrayHandle->Array = NewReference;
  1601.                                     /* if we added to the array, then we have to zero those elements */
  1602.                                     if (SizeDifference > 0)
  1603.                                         {
  1604.                                             long                    Limit;
  1605.  
  1606.                                             Limit = Stack[StackPtr].Data.Integer;
  1607.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1608.                                                 {
  1609.                                                     PRNGCHK(NewReference,&(((float*)NewReference)[Index]),
  1610.                                                         sizeof(float));
  1611.                                                     ((float*)NewReference)[Index] = 0;
  1612.                                                 }
  1613.                                         }
  1614.                                 }
  1615.                              else
  1616.                                 {
  1617.                                     ErrorCode = eEvalArrayDoesntExist;
  1618.                                     goto ExceptionPoint;
  1619.                                 }
  1620.                             StackPtr -= 1;
  1621.                             break;
  1622.                         case epResizeDoubleArray2:
  1623.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1624.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1625.                                 "EvaluatePcode [epResizeDoubleArray]: bad stack element type"));
  1626.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1627.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1628.                                 "EvaluatePcode [epResizeDoubleArray]:  array slot of wrong type"));
  1629.                             if (Stack[StackPtr].Data.Integer < 0)
  1630.                                 {
  1631.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1632.                                     goto ExceptionPoint;
  1633.                                 }
  1634.                             if (Stack[StackPtr - 1].Data.ArrayHandle != NIL)
  1635.                                 {
  1636.                                     void*                    OldReference;
  1637.                                     void*                    NewReference;
  1638.                                     long                    SizeDifference;
  1639.  
  1640.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  1641.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  1642.                                     OldReference = Stack[StackPtr - 1].Data.ArrayHandle->Array;
  1643.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1644.                                         - (PtrSize((char*)OldReference) / sizeof(double));
  1645.                                     NewReference = ResizePtr((char*)OldReference,
  1646.                                         Stack[StackPtr].Data.Integer * sizeof(double));
  1647.                                     if (NewReference == NIL)
  1648.                                         {
  1649.                                             ErrorCode = eEvalOutOfMemory;
  1650.                                             goto ExceptionPoint;
  1651.                                         }
  1652.                                     /* now patch up the references */
  1653.                                     Stack[StackPtr - 1].Data.ArrayHandle->Array = NewReference;
  1654.                                     /* if we added to the array, then we have to zero those elements */
  1655.                                     if (SizeDifference > 0)
  1656.                                         {
  1657.                                             long                    Limit;
  1658.  
  1659.                                             Limit = Stack[StackPtr].Data.Integer;
  1660.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1661.                                                 {
  1662.                                                     PRNGCHK(NewReference,&(((double*)NewReference)[Index]),
  1663.                                                         sizeof(double));
  1664.                                                     ((double*)NewReference)[Index] = 0;
  1665.                                                 }
  1666.                                         }
  1667.                                 }
  1668.                              else
  1669.                                 {
  1670.                                     ErrorCode = eEvalArrayDoesntExist;
  1671.                                     goto ExceptionPoint;
  1672.                                 }
  1673.                             StackPtr -= 1;
  1674.                             break;
  1675.                         case epResizeFixedArray2:
  1676.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1677.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1678.                                 "EvaluatePcode [epResizeFixedArray]: bad stack element type"));
  1679.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  1680.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  1681.                                 "EvaluatePcode [epResizeFixedArray]:  array slot of wrong type"));
  1682.                             if (Stack[StackPtr].Data.Integer < 0)
  1683.                                 {
  1684.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  1685.                                     goto ExceptionPoint;
  1686.                                 }
  1687.                             if (Stack[StackPtr - 1].Data.ArrayHandle != NIL)
  1688.                                 {
  1689.                                     void*                    OldReference;
  1690.                                     void*                    NewReference;
  1691.                                     long                    SizeDifference;
  1692.  
  1693.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  1694.                                     CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  1695.                                     OldReference = Stack[StackPtr - 1].Data.ArrayHandle->Array;
  1696.                                     SizeDifference = Stack[StackPtr].Data.Integer
  1697.                                         - (PtrSize((char*)OldReference) / sizeof(largefixedsigned));
  1698.                                     NewReference = ResizePtr((char*)OldReference,
  1699.                                         Stack[StackPtr].Data.Integer * sizeof(largefixedsigned));
  1700.                                     if (NewReference == NIL)
  1701.                                         {
  1702.                                             ErrorCode = eEvalOutOfMemory;
  1703.                                             goto ExceptionPoint;
  1704.                                         }
  1705.                                     /* now patch up the references */
  1706.                                     Stack[StackPtr - 1].Data.ArrayHandle->Array = NewReference;
  1707.                                     /* if we added to the array, then we have to zero those elements */
  1708.                                     if (SizeDifference > 0)
  1709.                                         {
  1710.                                             long                    Limit;
  1711.  
  1712.                                             Limit = Stack[StackPtr].Data.Integer;
  1713.                                             for (Index = Limit - SizeDifference; Index < Limit; Index += 1)
  1714.                                                 {
  1715.                                                     PRNGCHK(NewReference,
  1716.                                                         &(((largefixedsigned*)NewReference)[Index]),
  1717.                                                         sizeof(largefixedsigned));
  1718.                                                     ((largefixedsigned*)NewReference)[Index] = 0;
  1719.                                                 }
  1720.                                         }
  1721.                                 }
  1722.                              else
  1723.                                 {
  1724.                                     ErrorCode = eEvalArrayDoesntExist;
  1725.                                     goto ExceptionPoint;
  1726.                                 }
  1727.                             StackPtr -= 1;
  1728.                             break;
  1729.  
  1730.                         case epStoreIntegerOnStack:
  1731.                             /*    -1         0    */
  1732.                             /* <opcode> <stackindex> */
  1733.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1734.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1735.                                 "EvaluatePcode [epStoreIntegerOnStack]: bad stack element type"));
  1736.                             PRNGCHK(CurrentProcedure,
  1737.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1738.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1739.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1740.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1741.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1742.                                 "EvaluatePcode [epStoreIntegerOnStack]:  array slot of wrong type"));
  1743.                             Stack[Index].Data.Integer = Stack[StackPtr].Data.Integer;
  1744.                             ProgramCounter += 1;
  1745.                             /* don't pop the value from the stack though */
  1746.                             break;
  1747.                         case epStoreFloatOnStack:
  1748.                             /*    -1         0    */
  1749.                             /* <opcode> <stackindex> */
  1750.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1751.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1752.                                 "EvaluatePcode [epStoreFloatOnStack]: bad stack element type"));
  1753.                             PRNGCHK(CurrentProcedure,
  1754.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1755.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1756.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1757.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1758.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1759.                                 "EvaluatePcode [epStoreFloatOnStack]:  array slot of wrong type"));
  1760.                             Stack[Index].Data.Float = Stack[StackPtr].Data.Float;
  1761.                             ProgramCounter += 1;
  1762.                             /* don't pop the value from the stack though */
  1763.                             break;
  1764.                         case epStoreDoubleOnStack:
  1765.                             /*    -1         0    */
  1766.                             /* <opcode> <stackindex> */
  1767.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1768.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  1769.                                 "EvaluatePcode [epStoreDoubleOnStack]: bad stack element type"));
  1770.                             PRNGCHK(CurrentProcedure,
  1771.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1772.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1773.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1774.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1775.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1776.                                 "EvaluatePcode [epStoreDoubleOnStack]:  array slot of wrong type"));
  1777.                             Stack[Index].Data.Double = Stack[StackPtr].Data.Double;
  1778.                             ProgramCounter += 1;
  1779.                             /* don't pop the value from the stack though */
  1780.                             break;
  1781.                         case epStoreArrayOnStack:
  1782.                             /*    -1         0    */
  1783.                             /* <opcode> <stackindex> */
  1784.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1785.                             ERROR(Stack[StackPtr].ElementType != esArray,PRERR(ForceAbort,
  1786.                                 "EvaluatePcode [epStoreArrayOnStack]: bad stack element type"));
  1787.                             /* this one has to make sure it deallocates an array that it overwrites. */
  1788.                             PRNGCHK(CurrentProcedure,
  1789.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1790.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1791.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1792.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1793.                             ERROR((Stack[Index].ElementType != esScalar)
  1794.                                 && (Stack[Index].ElementType != esArray),
  1795.                                 PRERR(ForceAbort,
  1796.                                 "EvaluatePcode [epStoreArrayOnStack]:  array slot of wrong type"));
  1797.                             if ((Stack[Index].ElementType == esArray)
  1798.                                 && (Stack[Index].Data.ArrayHandle != NIL))
  1799.                                 {
  1800.                                     DisposeIfOnStackOnlyOnce(Stack,StackPtr,Index);
  1801.                                 }
  1802.                             Stack[Index].Data.ArrayHandle = Stack[StackPtr].Data.ArrayHandle;
  1803.                             if (Stack[Index].Data.ArrayHandle != NIL)
  1804.                                 {
  1805.                                     /* increment the reference count */
  1806.                                     Stack[Index].Data.ArrayHandle->RefCount += 1;
  1807.                                 }
  1808.                             Stack[Index].ElementType = esArray;
  1809.                             ProgramCounter += 1;
  1810.                             /* don't pop the value from the stack though */
  1811.                             break;
  1812.                         case epLoadIntegerFromStack:
  1813.                             /*    -1         0    */
  1814.                             /* <opcode> <stackindex> */
  1815.                             PRNGCHK(CurrentProcedure,
  1816.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1817.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1818.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1819.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1820.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1821.                                 "EvaluatePcode [epLoadIntegerFromStack]:  array slot of wrong type"));
  1822.                             StackPtr += 1;
  1823.                             if (StackPtr >= StackSize)
  1824.                                 {
  1825.                                     StackElement*            NewStack;
  1826.  
  1827.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1828.                                         * sizeof(StackElement));
  1829.                                     if (NewStack == NIL)
  1830.                                         {
  1831.                                             StackPtr -= 1;
  1832.                                             ErrorCode = eEvalOutOfMemory;
  1833.                                             goto ExceptionPoint;
  1834.                                         }
  1835.                                     Stack = NewStack;
  1836.                                     StackSize += 8;
  1837.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1838.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadIntegerFromStack]: stack size inconsistency"));
  1839.                                 }
  1840.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1841.                             Stack[StackPtr].ElementType = esScalar;
  1842.                             Stack[StackPtr].Data.Integer = Stack[Index].Data.Integer;
  1843.                             ProgramCounter += 1;
  1844.                             break;
  1845.                         case epLoadFloatFromStack:
  1846.                             /*    -1         0    */
  1847.                             /* <opcode> <stackindex> */
  1848.                             PRNGCHK(CurrentProcedure,
  1849.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1850.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1851.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1852.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1853.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1854.                                 "EvaluatePcode [epLoadFloatFromStack]:  array slot of wrong type"));
  1855.                             StackPtr += 1;
  1856.                             if (StackPtr >= StackSize)
  1857.                                 {
  1858.                                     StackElement*            NewStack;
  1859.  
  1860.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1861.                                         * sizeof(StackElement));
  1862.                                     if (NewStack == NIL)
  1863.                                         {
  1864.                                             StackPtr -= 1;
  1865.                                             ErrorCode = eEvalOutOfMemory;
  1866.                                             goto ExceptionPoint;
  1867.                                         }
  1868.                                     Stack = NewStack;
  1869.                                     StackSize += 8;
  1870.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1871.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadFloatFromStack]: stack size inconsistency"));
  1872.                                 }
  1873.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1874.                             Stack[StackPtr].ElementType = esScalar;
  1875.                             Stack[StackPtr].Data.Float = Stack[Index].Data.Float;
  1876.                             ProgramCounter += 1;
  1877.                             break;
  1878.                         case epLoadDoubleFromStack:
  1879.                             /*    -1         0    */
  1880.                             /* <opcode> <stackindex> */
  1881.                             PRNGCHK(CurrentProcedure,
  1882.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1883.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1884.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1885.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1886.                             ERROR(Stack[Index].ElementType != esScalar,PRERR(ForceAbort,
  1887.                                 "EvaluatePcode [epLoadDoubleFromStack]:  array slot of wrong type"));
  1888.                             StackPtr += 1;
  1889.                             if (StackPtr >= StackSize)
  1890.                                 {
  1891.                                     StackElement*            NewStack;
  1892.  
  1893.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1894.                                         * sizeof(StackElement));
  1895.                                     if (NewStack == NIL)
  1896.                                         {
  1897.                                             StackPtr -= 1;
  1898.                                             ErrorCode = eEvalOutOfMemory;
  1899.                                             goto ExceptionPoint;
  1900.                                         }
  1901.                                     Stack = NewStack;
  1902.                                     StackSize += 8;
  1903.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1904.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadDoubleFromStack]: stack size inconsistency"));
  1905.                                 }
  1906.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1907.                             Stack[StackPtr].ElementType = esScalar;
  1908.                             Stack[StackPtr].Data.Double = Stack[Index].Data.Double;
  1909.                             ProgramCounter += 1;
  1910.                             break;
  1911.                         case epLoadArrayFromStack:
  1912.                             /*    -1         0    */
  1913.                             /* <opcode> <stackindex> */
  1914.                             PRNGCHK(CurrentProcedure,
  1915.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1916.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1917.                             Index = StackPtr + CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1918.                             PRNGCHK(Stack,&(Stack[Index]),sizeof(Stack[Index]));
  1919.                             ERROR(Stack[Index].ElementType != esArray,PRERR(ForceAbort,
  1920.                                 "EvaluatePcode [epLoadArrayFromStack]:  array slot of wrong type"));
  1921.                             StackPtr += 1;
  1922.                             if (StackPtr >= StackSize)
  1923.                                 {
  1924.                                     StackElement*            NewStack;
  1925.  
  1926.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1927.                                         * sizeof(StackElement));
  1928.                                     if (NewStack == NIL)
  1929.                                         {
  1930.                                             StackPtr -= 1;
  1931.                                             ErrorCode = eEvalOutOfMemory;
  1932.                                             goto ExceptionPoint;
  1933.                                         }
  1934.                                     Stack = NewStack;
  1935.                                     StackSize += 8;
  1936.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1937.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadArrayFromStack]: stack size inconsistency"));
  1938.                                 }
  1939.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1940.                             Stack[StackPtr].Data.ArrayHandle = Stack[Index].Data.ArrayHandle;
  1941.                             if (Stack[StackPtr].Data.ArrayHandle != NIL)
  1942.                                 {
  1943.                                     /* increment the reference count */
  1944.                                     Stack[StackPtr].Data.ArrayHandle->RefCount += 1;
  1945.                                 }
  1946.                             Stack[StackPtr].ElementType = esArray;
  1947.                             ProgramCounter += 1;
  1948.                             break;
  1949.  
  1950.                         case epStackPop:
  1951.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1952.                             if ((Stack[StackPtr].ElementType == esArray)
  1953.                                 && (Stack[StackPtr].Data.ArrayHandle != NIL))
  1954.                                 {
  1955.                                     DisposeIfNotOnStack(Stack,StackPtr);
  1956.                                 }
  1957.                             StackPtr -= 1;
  1958.                             break;
  1959.  
  1960.                         case epStackAllocate:
  1961.                             StackPtr += 1;
  1962.                             if (StackPtr >= StackSize)
  1963.                                 {
  1964.                                     StackElement*            NewStack;
  1965.  
  1966.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  1967.                                         * sizeof(StackElement));
  1968.                                     if (NewStack == NIL)
  1969.                                         {
  1970.                                             StackPtr -= 1;
  1971.                                             ErrorCode = eEvalOutOfMemory;
  1972.                                             goto ExceptionPoint;
  1973.                                         }
  1974.                                     Stack = NewStack;
  1975.                                     StackSize += 8;
  1976.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  1977.                                         PRERR(ForceAbort,"EvaluatePcode [epStackAllocate]: stack size inconsistency"));
  1978.                                 }
  1979.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1980.                             Stack[StackPtr].ElementType = esScalar;
  1981.                             break;
  1982.  
  1983.                         case epStackPopMultiple:
  1984.                             /*     -1       0   */
  1985.                             /* <opcode> <numwords> */
  1986.                             PRNGCHK(CurrentProcedure,
  1987.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  1988.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  1989.                             Index = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  1990.                             while (Index > 0)
  1991.                                 {
  1992.                                     PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  1993.                                     if ((Stack[StackPtr].ElementType == esArray)
  1994.                                         && (Stack[StackPtr].Data.ArrayHandle != NIL))
  1995.                                         {
  1996.                                             DisposeIfNotOnStack(Stack,StackPtr);
  1997.                                         }
  1998.                                     StackPtr -= 1;
  1999.                                     Index -= 1;
  2000.                                 }
  2001.                             ProgramCounter += 1;
  2002.                             break;
  2003.  
  2004.                         /* deallocate multiple cells under the current top */
  2005.                         case epStackDeallocateUnder:
  2006.                             /*    -1        0   */
  2007.                             /* <opcode> <numwords> */
  2008.                             PRNGCHK(CurrentProcedure,
  2009.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  2010.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  2011.                             /* get the number of cells to deallocate */
  2012.                             Index = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  2013.                             Scan = StackPtr;
  2014.                             while (Index > 0)
  2015.                                 {
  2016.                                     PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2017.                                     if ((Stack[StackPtr - 1].ElementType == esArray)
  2018.                                         && (Stack[StackPtr - 1].Data.ArrayHandle != NIL))
  2019.                                         {
  2020.                                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2021.                                         }
  2022.                                     PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2023.                                     Stack[StackPtr - 1] = Stack[StackPtr];
  2024.                                     StackPtr -= 1;
  2025.                                     Index -= 1;
  2026.                                 }
  2027.                             Stack[StackPtr] = Stack[Scan];
  2028.                             ProgramCounter += 1;
  2029.                             break;
  2030.  
  2031.                         /* duplicate the top word of the stack */
  2032.                         case epDuplicate:
  2033.                             StackPtr += 1;
  2034.                             if (StackPtr >= StackSize)
  2035.                                 {
  2036.                                     StackElement*            NewStack;
  2037.  
  2038.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2039.                                         * sizeof(StackElement));
  2040.                                     if (NewStack == NIL)
  2041.                                         {
  2042.                                             StackPtr -= 1;
  2043.                                             ErrorCode = eEvalOutOfMemory;
  2044.                                             goto ExceptionPoint;
  2045.                                         }
  2046.                                     Stack = NewStack;
  2047.                                     StackSize += 8;
  2048.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2049.                                         PRERR(ForceAbort,"EvaluatePcode [epLoadDoubleFromStack]: stack size inconsistency"));
  2050.                                 }
  2051.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2052.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2053.                             Stack[StackPtr] = Stack[StackPtr - 1];
  2054.                             if ((Stack[StackPtr].ElementType == esArray)
  2055.                                 && (Stack[StackPtr].Data.ArrayHandle != NIL))
  2056.                                 {
  2057.                                     /* increment the reference count */
  2058.                                     Stack[StackPtr].Data.ArrayHandle->RefCount += 1;
  2059.                                 }
  2060.                             break;
  2061.  
  2062.                         /* no operation */
  2063.                         case epNop:
  2064.                             break;
  2065.  
  2066.                         /* new array allocation procedures */
  2067.                         case epMakeBooleanArray:
  2068.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2069.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2070.                                 "EvaluatePcode [epMakeBooleanArray]: bad stack element type"));
  2071.                             Index = Stack[StackPtr].Data.Integer;
  2072.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2073.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2074.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2075.                                 {
  2076.                                     ErrorCode = eEvalOutOfMemory;
  2077.                                     goto ExceptionPoint;
  2078.                                 }
  2079.                             Stack[StackPtr].Data.ArrayHandle->Array = AllocPtrCanFail(Index,
  2080.                                 "EvalPcodeBoolArray");
  2081.                             if (Stack[StackPtr].Data.ArrayHandle->Array == NIL)
  2082.                                 {
  2083.                                     ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2084.                                     Stack[StackPtr].Data.ArrayHandle = NIL;
  2085.                                     ErrorCode = eEvalOutOfMemory;
  2086.                                     goto ExceptionPoint;
  2087.                                 }
  2088.                             Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2089.                             Stack[StackPtr].ElementType = esArray;
  2090.                             for (Scan = 0; Scan < Index; Scan += 1)
  2091.                                 {
  2092.                                     PRNGCHK(Stack[StackPtr].Data.ArrayHandle->Array,
  2093.                                         &(((char*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan]),
  2094.                                         sizeof(char));
  2095.                                     ((char*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan] = 0;
  2096.                                 }
  2097.                             break;
  2098.                         case epMakeIntegerArray:
  2099.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2100.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2101.                                 "EvaluatePcode [epMakeIntegerArray]: bad stack element type"));
  2102.                             Index = Stack[StackPtr].Data.Integer;
  2103.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2104.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2105.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2106.                                 {
  2107.                                     ErrorCode = eEvalOutOfMemory;
  2108.                                     goto ExceptionPoint;
  2109.                                 }
  2110.                             Stack[StackPtr].Data.ArrayHandle->Array = AllocPtrCanFail(
  2111.                                 Index * sizeof(long),"EvalPcodeIntArray");
  2112.                             if (Stack[StackPtr].Data.ArrayHandle->Array == NIL)
  2113.                                 {
  2114.                                     ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2115.                                     Stack[StackPtr].Data.ArrayHandle = NIL;
  2116.                                     ErrorCode = eEvalOutOfMemory;
  2117.                                     goto ExceptionPoint;
  2118.                                 }
  2119.                             Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2120.                             Stack[StackPtr].ElementType = esArray;
  2121.                             for (Scan = 0; Scan < Index; Scan += 1)
  2122.                                 {
  2123.                                     PRNGCHK(Stack[StackPtr].Data.ArrayHandle->Array,
  2124.                                         &(((long*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan]),
  2125.                                         sizeof(long));
  2126.                                     ((long*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan] = 0;
  2127.                                 }
  2128.                             break;
  2129.                         case epMakeFloatArray:
  2130.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2131.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2132.                                 "EvaluatePcode [epMakeFloatArray]: bad stack element type"));
  2133.                             Index = Stack[StackPtr].Data.Integer;
  2134.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2135.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2136.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2137.                                 {
  2138.                                     ErrorCode = eEvalOutOfMemory;
  2139.                                     goto ExceptionPoint;
  2140.                                 }
  2141.                             Stack[StackPtr].Data.ArrayHandle->Array = AllocPtrCanFail(
  2142.                                 Index * sizeof(float),"EvalPcodeFloatArray");
  2143.                             if (Stack[StackPtr].Data.ArrayHandle->Array == NIL)
  2144.                                 {
  2145.                                     ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2146.                                     Stack[StackPtr].Data.ArrayHandle = NIL;
  2147.                                     ErrorCode = eEvalOutOfMemory;
  2148.                                     goto ExceptionPoint;
  2149.                                 }
  2150.                             Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2151.                             Stack[StackPtr].ElementType = esArray;
  2152.                             for (Scan = 0; Scan < Index; Scan += 1)
  2153.                                 {
  2154.                                     PRNGCHK(Stack[StackPtr].Data.ArrayHandle->Array,
  2155.                                         &(((float*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan]),
  2156.                                         sizeof(float));
  2157.                                     ((float*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan] = 0;
  2158.                                 }
  2159.                             break;
  2160.                         case epMakeDoubleArray:
  2161.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2162.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2163.                                 "EvaluatePcode [epMakeDoubleArray]: bad stack element type"));
  2164.                             Index = Stack[StackPtr].Data.Integer;
  2165.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2166.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2167.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2168.                                 {
  2169.                                     ErrorCode = eEvalOutOfMemory;
  2170.                                     goto ExceptionPoint;
  2171.                                 }
  2172.                             Stack[StackPtr].Data.ArrayHandle->Array = AllocPtrCanFail(
  2173.                                 Index * sizeof(double),"EvalPcodeDoubleArray");
  2174.                             if (Stack[StackPtr].Data.ArrayHandle->Array == NIL)
  2175.                                 {
  2176.                                     ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2177.                                     Stack[StackPtr].Data.ArrayHandle = NIL;
  2178.                                     ErrorCode = eEvalOutOfMemory;
  2179.                                     goto ExceptionPoint;
  2180.                                 }
  2181.                             Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2182.                             Stack[StackPtr].ElementType = esArray;
  2183.                             for (Scan = 0; Scan < Index; Scan += 1)
  2184.                                 {
  2185.                                     PRNGCHK(Stack[StackPtr].Data.ArrayHandle->Array,
  2186.                                         &(((double*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan]),
  2187.                                         sizeof(double));
  2188.                                     ((double*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan] = 0;
  2189.                                 }
  2190.                             break;
  2191.                         case epMakeFixedArray:
  2192.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2193.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2194.                                 "EvaluatePcode [epMakeFixedArray]: bad stack element type"));
  2195.                             Index = Stack[StackPtr].Data.Integer;
  2196.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2197.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2198.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2199.                                 {
  2200.                                     ErrorCode = eEvalOutOfMemory;
  2201.                                     goto ExceptionPoint;
  2202.                                 }
  2203.                             Stack[StackPtr].Data.ArrayHandle->Array = AllocPtrCanFail(
  2204.                                 Index * sizeof(long),"EvalPcodeFixedArray");
  2205.                             if (Stack[StackPtr].Data.ArrayHandle->Array == NIL)
  2206.                                 {
  2207.                                     ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2208.                                     Stack[StackPtr].Data.ArrayHandle = NIL;
  2209.                                     ErrorCode = eEvalOutOfMemory;
  2210.                                     goto ExceptionPoint;
  2211.                                 }
  2212.                             Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2213.                             Stack[StackPtr].ElementType = esArray;
  2214.                             for (Scan = 0; Scan < Index; Scan += 1)
  2215.                                 {
  2216.                                     PRNGCHK(Stack[StackPtr].Data.ArrayHandle->Array,
  2217.                                         &(((largefixedsigned*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan]),
  2218.                                         sizeof(largefixedsigned));
  2219.                                     ((largefixedsigned*)(Stack[StackPtr].Data.ArrayHandle->Array))[Scan] = 0;
  2220.                                 }
  2221.                             break;
  2222.  
  2223.                         case epStoreBooleanIntoArray2:
  2224.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2225.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2226.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2227.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2228.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2229.                                 "EvaluatePcode [epStoreBooleanIntoArray]: bad stack element type"));
  2230.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2231.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2232.                                 "EvaluatePcode [epStoreBooleanIntoArray]:  not an array"));
  2233.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2234.                                 {
  2235.                                     ErrorCode = eEvalArrayDoesntExist;
  2236.                                     goto ExceptionPoint;
  2237.                                 }
  2238.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2239.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2240.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2241.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)))
  2242.                                 {
  2243.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2244.                                     goto ExceptionPoint;
  2245.                                 }
  2246.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2247.                                 &(((char*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2248.                                 Stack[StackPtr].Data.Integer]),sizeof(char));
  2249.                             ((char*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2250.                                 Stack[StackPtr].Data.Integer] = Stack[StackPtr - 2].Data.Integer;
  2251.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2252.                             StackPtr -= 2; /* pop subscript and reference */
  2253.                             break;
  2254.                         case epStoreIntegerIntoArray2:
  2255.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2256.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2257.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2258.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2259.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2260.                                 "EvaluatePcode [epStoreIntegerIntoArray]: bad stack element type"));
  2261.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2262.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2263.                                 "EvaluatePcode [epStoreIntegerIntoArray]:  not an array"));
  2264.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2265.                                 {
  2266.                                     ErrorCode = eEvalArrayDoesntExist;
  2267.                                     goto ExceptionPoint;
  2268.                                 }
  2269.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2270.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2271.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2272.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2273.                                 / sizeof(long)))
  2274.                                 {
  2275.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2276.                                     goto ExceptionPoint;
  2277.                                 }
  2278.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2279.                                 &(((long*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2280.                                 Stack[StackPtr].Data.Integer]),sizeof(long));
  2281.                             ((long*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2282.                                 Stack[StackPtr].Data.Integer] = Stack[StackPtr - 2].Data.Integer;
  2283.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2284.                             StackPtr -= 2; /* pop subscript and reference */
  2285.                             break;
  2286.                         case epStoreFloatIntoArray2:
  2287.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2288.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2289.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2290.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2291.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2292.                                 "EvaluatePcode [epStoreFloatIntoArray]: bad stack element type"));
  2293.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2294.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2295.                                 "EvaluatePcode [epStoreFloatIntoArray]:  not an array"));
  2296.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2297.                                 {
  2298.                                     ErrorCode = eEvalArrayDoesntExist;
  2299.                                     goto ExceptionPoint;
  2300.                                 }
  2301.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2302.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2303.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2304.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2305.                                 / sizeof(float)))
  2306.                                 {
  2307.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2308.                                     goto ExceptionPoint;
  2309.                                 }
  2310.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2311.                                 &(((float*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2312.                                 Stack[StackPtr].Data.Integer]),sizeof(float));
  2313.                             ((float*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2314.                                 Stack[StackPtr].Data.Integer] = Stack[StackPtr - 2].Data.Float;
  2315.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2316.                             StackPtr -= 2; /* pop subscript and reference */
  2317.                             break;
  2318.                         case epStoreDoubleIntoArray2:
  2319.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2320.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2321.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2322.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2323.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2324.                                 "EvaluatePcode [epStoreDoubleIntoArray]: bad stack element type"));
  2325.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2326.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2327.                                 "EvaluatePcode [epStoreDoubleIntoArray]:  not an array"));
  2328.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2329.                                 {
  2330.                                     ErrorCode = eEvalArrayDoesntExist;
  2331.                                     goto ExceptionPoint;
  2332.                                 }
  2333.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2334.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2335.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2336.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2337.                                 / sizeof(double)))
  2338.                                 {
  2339.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2340.                                     goto ExceptionPoint;
  2341.                                 }
  2342.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2343.                                 &(((double*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2344.                                 Stack[StackPtr].Data.Integer]),sizeof(double));
  2345.                             ((double*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2346.                                 Stack[StackPtr].Data.Integer] = Stack[StackPtr - 2].Data.Double;
  2347.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2348.                             StackPtr -= 2; /* pop subscript and reference */
  2349.                             break;
  2350.                         case epStoreFixedIntoArray2:
  2351.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2352.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2353.                             PRNGCHK(Stack,&(Stack[StackPtr - 2]),sizeof(Stack[StackPtr - 2]));
  2354.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  2355.                                 || (Stack[StackPtr - 2].ElementType != esScalar),PRERR(ForceAbort,
  2356.                                 "EvaluatePcode [epStoreFixedIntoArray]: bad stack element type"));
  2357.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2358.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2359.                                 "EvaluatePcode [epStoreFixedIntoArray]:  not an array"));
  2360.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2361.                                 {
  2362.                                     ErrorCode = eEvalArrayDoesntExist;
  2363.                                     goto ExceptionPoint;
  2364.                                 }
  2365.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2366.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2367.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2368.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2369.                                 / sizeof(largefixedsigned)))
  2370.                                 {
  2371.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2372.                                     goto ExceptionPoint;
  2373.                                 }
  2374.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2375.                                 &(((largefixedsigned*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2376.                                 Stack[StackPtr].Data.Integer]),sizeof(largefixedsigned));
  2377.                             ((largefixedsigned*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2378.                                 Stack[StackPtr].Data.Integer] = Stack[StackPtr - 2].Data.Integer;
  2379.                             DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2380.                             StackPtr -= 2; /* pop subscript and reference */
  2381.                             break;
  2382.  
  2383.                         case epLoadBooleanFromArray2:
  2384.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2385.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2386.                                 "EvaluatePcode [epLoadBooleanFromArray]: bad stack element type"));
  2387.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2388.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2389.                                 "EvaluatePcode [epLoadBooleanFromArray]:  not an array"));
  2390.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2391.                                 {
  2392.                                     ErrorCode = eEvalArrayDoesntExist;
  2393.                                     goto ExceptionPoint;
  2394.                                 }
  2395.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2396.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2397.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2398.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)))
  2399.                                 {
  2400.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2401.                                     goto ExceptionPoint;
  2402.                                 }
  2403.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2404.                                 &(((char*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2405.                                 Stack[StackPtr].Data.Integer]),sizeof(char));
  2406.                             {
  2407.                                 long                        BoolTemp;
  2408.  
  2409.                                 BoolTemp = ((char*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2410.                                     Stack[StackPtr].Data.Integer];
  2411.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2412.                                 StackPtr -= 1;
  2413.                                 Stack[StackPtr].ElementType = esScalar;
  2414.                                 Stack[StackPtr].Data.Integer = BoolTemp;
  2415.                             }
  2416.                             break;
  2417.                         case epLoadIntegerFromArray2:
  2418.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2419.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2420.                                 "EvaluatePcode [epLoadIntegerFromArray]: bad stack element type"));
  2421.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2422.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2423.                                 "EvaluatePcode [epLoadIntegerFromArray]:  not an array"));
  2424.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2425.                                 {
  2426.                                     ErrorCode = eEvalArrayDoesntExist;
  2427.                                     goto ExceptionPoint;
  2428.                                 }
  2429.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2430.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2431.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2432.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2433.                                 / sizeof(long)))
  2434.                                 {
  2435.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2436.                                     goto ExceptionPoint;
  2437.                                 }
  2438.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2439.                                 &(((long*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2440.                                 Stack[StackPtr].Data.Integer]),sizeof(long));
  2441.                             {
  2442.                                 long                        IntegerTemp;
  2443.  
  2444.                                 IntegerTemp = ((long*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2445.                                     Stack[StackPtr].Data.Integer];
  2446.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2447.                                 StackPtr -= 1;
  2448.                                 Stack[StackPtr].ElementType = esScalar;
  2449.                                 Stack[StackPtr].Data.Integer = IntegerTemp;
  2450.                             }
  2451.                             break;
  2452.                         case epLoadFloatFromArray2:
  2453.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2454.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2455.                                 "EvaluatePcode [epLoadFloatFromArray]: bad stack element type"));
  2456.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2457.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2458.                                 "EvaluatePcode [epLoadFloatFromArray]:  not an array"));
  2459.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2460.                                 {
  2461.                                     ErrorCode = eEvalArrayDoesntExist;
  2462.                                     goto ExceptionPoint;
  2463.                                 }
  2464.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2465.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2466.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2467.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2468.                                 / sizeof(float)))
  2469.                                 {
  2470.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2471.                                     goto ExceptionPoint;
  2472.                                 }
  2473.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2474.                                 &(((float*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2475.                                 Stack[StackPtr].Data.Integer]),sizeof(float));
  2476.                             {
  2477.                                 float                        FloatTemp;
  2478.  
  2479.                                 FloatTemp = ((float*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2480.                                     Stack[StackPtr].Data.Integer];
  2481.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2482.                                 StackPtr -= 1;
  2483.                                 Stack[StackPtr].ElementType = esScalar;
  2484.                                 Stack[StackPtr].Data.Float = FloatTemp;
  2485.                             }
  2486.                             break;
  2487.                         case epLoadDoubleFromArray2:
  2488.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2489.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2490.                                 "EvaluatePcode [epLoadDoubleFromArray]: bad stack element type"));
  2491.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2492.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2493.                                 "EvaluatePcode [epLoadDoubleFromArray]:  not an array"));
  2494.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2495.                                 {
  2496.                                     ErrorCode = eEvalArrayDoesntExist;
  2497.                                     goto ExceptionPoint;
  2498.                                 }
  2499.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2500.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2501.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2502.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2503.                                 / sizeof(double)))
  2504.                                 {
  2505.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2506.                                     goto ExceptionPoint;
  2507.                                 }
  2508.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2509.                                 &(((double*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2510.                                 Stack[StackPtr].Data.Integer]),sizeof(double));
  2511.                             {
  2512.                                 double                        DoubleTemp;
  2513.  
  2514.                                 DoubleTemp = ((double*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))[
  2515.                                     Stack[StackPtr].Data.Integer];
  2516.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2517.                                 StackPtr -= 1;
  2518.                                 Stack[StackPtr].ElementType = esScalar;
  2519.                                 Stack[StackPtr].Data.Double = DoubleTemp;
  2520.                             }
  2521.                             break;
  2522.                         case epLoadFixedFromArray2:
  2523.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2524.                             ERROR(Stack[StackPtr].ElementType != esScalar,PRERR(ForceAbort,
  2525.                                 "EvaluatePcode [epLoadFixedFromArray]: bad stack element type"));
  2526.                             PRNGCHK(Stack,&(Stack[StackPtr - 1]),sizeof(Stack[StackPtr - 1]));
  2527.                             ERROR(Stack[StackPtr - 1].ElementType != esArray,PRERR(ForceAbort,
  2528.                                 "EvaluatePcode [epLoadFixedFromArray]:  not an array"));
  2529.                             if (Stack[StackPtr - 1].Data.ArrayHandle == NIL)
  2530.                                 {
  2531.                                     ErrorCode = eEvalArrayDoesntExist;
  2532.                                     goto ExceptionPoint;
  2533.                                 }
  2534.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle);
  2535.                             CheckPtrExistence(Stack[StackPtr - 1].Data.ArrayHandle->Array);
  2536.                             if ((Stack[StackPtr].Data.Integer < 0) || (Stack[StackPtr].Data.Integer
  2537.                                 >= PtrSize((char*)Stack[StackPtr - 1].Data.ArrayHandle->Array)
  2538.                                 / sizeof(largefixedsigned)))
  2539.                                 {
  2540.                                     ErrorCode = eEvalArraySubscriptOutOfRange;
  2541.                                     goto ExceptionPoint;
  2542.                                 }
  2543.                             PRNGCHK(Stack[StackPtr - 1].Data.ArrayHandle->Array,
  2544.                                 &(((largefixedsigned*)(Stack[StackPtr - 1].Data.ArrayHandle->Array))
  2545.                                 [Stack[StackPtr].Data.Integer]),sizeof(largefixedsigned));
  2546.                             {
  2547.                                 largefixedsigned        FixedTemp;
  2548.  
  2549.                                 FixedTemp = ((largefixedsigned*)(Stack[StackPtr - 1].Data
  2550.                                     .ArrayHandle->Array))[Stack[StackPtr].Data.Integer];
  2551.                                 DisposeIfOnStackOnlyOnce(Stack,StackPtr,StackPtr - 1);
  2552.                                 StackPtr -= 1;
  2553.                                 Stack[StackPtr].ElementType = esScalar;
  2554.                                 Stack[StackPtr].Data.Integer = FixedTemp;
  2555.                             }
  2556.                             break;
  2557.  
  2558.                         /* load immediate values */
  2559.                         case epLoadImmediateInteger:
  2560.                             /*    -1        0   */
  2561.                             /* <opcode> <integer>; also used for boolean & fixed */
  2562.                             StackPtr += 1;
  2563.                             if (StackPtr >= StackSize)
  2564.                                 {
  2565.                                     StackElement*            NewStack;
  2566.  
  2567.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2568.                                         * sizeof(StackElement));
  2569.                                     if (NewStack == NIL)
  2570.                                         {
  2571.                                             StackPtr -= 1;
  2572.                                             ErrorCode = eEvalOutOfMemory;
  2573.                                             goto ExceptionPoint;
  2574.                                         }
  2575.                                     Stack = NewStack;
  2576.                                     StackSize += 8;
  2577.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2578.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2579.                                 }
  2580.                             PRNGCHK(CurrentProcedure,
  2581.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateInteger),
  2582.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateInteger));
  2583.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2584.                             Stack[StackPtr].Data.Integer
  2585.                                 = CurrentProcedure[ProgramCounter + 0].ImmediateInteger;
  2586.                             Stack[StackPtr].ElementType = esScalar;
  2587.                             ProgramCounter += 1;
  2588.                             break;
  2589.                         case epLoadImmediateFloat:
  2590.                             /*    -1        0   */
  2591.                             /* <opcode> <integer>; also used for boolean & fixed */
  2592.                             StackPtr += 1;
  2593.                             if (StackPtr >= StackSize)
  2594.                                 {
  2595.                                     StackElement*            NewStack;
  2596.  
  2597.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2598.                                         * sizeof(StackElement));
  2599.                                     if (NewStack == NIL)
  2600.                                         {
  2601.                                             StackPtr -= 1;
  2602.                                             ErrorCode = eEvalOutOfMemory;
  2603.                                             goto ExceptionPoint;
  2604.                                         }
  2605.                                     Stack = NewStack;
  2606.                                     StackSize += 8;
  2607.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2608.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2609.                                 }
  2610.                             PRNGCHK(CurrentProcedure,
  2611.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateFloat),
  2612.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateFloat));
  2613.                             PRNGCHK(CurrentProcedure[ProgramCounter + 0].ImmediateFloat,
  2614.                                 &(*(CurrentProcedure[ProgramCounter + 0].ImmediateFloat)),sizeof(float));
  2615.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2616.                             Stack[StackPtr].Data.Float
  2617.                                 = *(CurrentProcedure[ProgramCounter + 0].ImmediateFloat);
  2618.                             Stack[StackPtr].ElementType = esScalar;
  2619.                             ProgramCounter += 1;
  2620.                             break;
  2621.                         case epLoadImmediateDouble:
  2622.                             /*    -1        0   */
  2623.                             /* <opcode> <integer>; also used for boolean & fixed */
  2624.                             StackPtr += 1;
  2625.                             if (StackPtr >= StackSize)
  2626.                                 {
  2627.                                     StackElement*            NewStack;
  2628.  
  2629.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2630.                                         * sizeof(StackElement));
  2631.                                     if (NewStack == NIL)
  2632.                                         {
  2633.                                             StackPtr -= 1;
  2634.                                             ErrorCode = eEvalOutOfMemory;
  2635.                                             goto ExceptionPoint;
  2636.                                         }
  2637.                                     Stack = NewStack;
  2638.                                     StackSize += 8;
  2639.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2640.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2641.                                 }
  2642.                             PRNGCHK(CurrentProcedure,
  2643.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateDouble),
  2644.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateDouble));
  2645.                             PRNGCHK(CurrentProcedure[ProgramCounter + 0].ImmediateDouble,
  2646.                                 &(*(CurrentProcedure[ProgramCounter + 0].ImmediateDouble)),
  2647.                                 sizeof(double));
  2648.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2649.                             Stack[StackPtr].Data.Double
  2650.                                 = *(CurrentProcedure[ProgramCounter + 0].ImmediateDouble);
  2651.                             Stack[StackPtr].ElementType = esScalar;
  2652.                             ProgramCounter += 1;
  2653.                             break;
  2654.                         case epLoadImmediateNILArray:
  2655.                             /* <opcode> */
  2656.                             StackPtr += 1;
  2657.                             if (StackPtr >= StackSize)
  2658.                                 {
  2659.                                     StackElement*            NewStack;
  2660.  
  2661.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2662.                                         * sizeof(StackElement));
  2663.                                     if (NewStack == NIL)
  2664.                                         {
  2665.                                             StackPtr -= 1;
  2666.                                             ErrorCode = eEvalOutOfMemory;
  2667.                                             goto ExceptionPoint;
  2668.                                         }
  2669.                                     Stack = NewStack;
  2670.                                     StackSize += 8;
  2671.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2672.                                         PRERR(ForceAbort,"EvaluatePcode [epFuncCallResolved]: stack size inconsistency"));
  2673.                                 }
  2674.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2675.                             Stack[StackPtr].Data.ArrayHandle = NIL;
  2676.                             Stack[StackPtr].ElementType = esArray;
  2677.                             break;
  2678.  
  2679.                         case epGetSampleLeftArray:
  2680.                             /*    -1           0    */
  2681.                             /* <opcode> ^"<namestring>" */
  2682.                             StackPtr += 1;
  2683.                             if (StackPtr >= StackSize)
  2684.                                 {
  2685.                                     StackElement*            NewStack;
  2686.  
  2687.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2688.                                         * sizeof(StackElement));
  2689.                                     if (NewStack == NIL)
  2690.                                         {
  2691.                                             StackPtr -= 1;
  2692.                                             ErrorCode = eEvalOutOfMemory;
  2693.                                             goto ExceptionPoint;
  2694.                                         }
  2695.                                     Stack = NewStack;
  2696.                                     StackSize += 8;
  2697.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2698.                                         PRERR(ForceAbort,"EvaluatePcode [epGetSampleLeftArray]: stack size inconsistency"));
  2699.                                 }
  2700.                             Stack[StackPtr].ElementType = esScalar;
  2701.                             PRNGCHK(CurrentProcedure,
  2702.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2703.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2704.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2705.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2706.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2707.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2708.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2709.                                 {
  2710.                                     ErrorCode = eEvalOutOfMemory;
  2711.                                     goto ExceptionPoint;
  2712.                                 }
  2713.                             switch ((*GetSampleLeftCopy)(Refcon,CurrentProcedure[
  2714.                                 ProgramCounter + 0].ImmediateString,
  2715.                                 (largefixedsigned**)&(Stack[StackPtr].Data.ArrayHandle->Array)))
  2716.                                 {
  2717.                                     case eEvalSampleNoError:
  2718.                                         CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  2719.                                         Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2720.                                         Stack[StackPtr].ElementType = esArray;
  2721.                                         break;
  2722.                                     case eEvalSampleUndefined:
  2723.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2724.                                         ErrorCode = eEvalGetSampleNotDefined;
  2725.                                         goto ExceptionPoint;
  2726.                                     case eEvalSampleWrongChannel:
  2727.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2728.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2729.                                         goto ExceptionPoint;
  2730.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2731.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2732.                                         ErrorCode = eEvalOutOfMemory;
  2733.                                         goto ExceptionPoint;
  2734.                                     default:
  2735.                                         EXECUTE(PRERR(ForceAbort,
  2736.                                             "EvaluatePcode [epGetSampleLeftArray]: unknown return code"));
  2737.                                         break;
  2738.                                 }
  2739.                             ProgramCounter += 1;
  2740.                             break;
  2741.                         case epGetSampleRightArray:
  2742.                             /*    -1           0    */
  2743.                             /* <opcode> ^"<namestring>" */
  2744.                             StackPtr += 1;
  2745.                             if (StackPtr >= StackSize)
  2746.                                 {
  2747.                                     StackElement*            NewStack;
  2748.  
  2749.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2750.                                         * sizeof(StackElement));
  2751.                                     if (NewStack == NIL)
  2752.                                         {
  2753.                                             StackPtr -= 1;
  2754.                                             ErrorCode = eEvalOutOfMemory;
  2755.                                             goto ExceptionPoint;
  2756.                                         }
  2757.                                     Stack = NewStack;
  2758.                                     StackSize += 8;
  2759.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2760.                                         PRERR(ForceAbort,"EvaluatePcode [epGetSampleRightArray]: stack size inconsistency"));
  2761.                                 }
  2762.                             Stack[StackPtr].ElementType = esScalar;
  2763.                             PRNGCHK(CurrentProcedure,
  2764.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2765.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2766.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2767.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2768.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2769.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2770.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2771.                                 {
  2772.                                     ErrorCode = eEvalOutOfMemory;
  2773.                                     goto ExceptionPoint;
  2774.                                 }
  2775.                             switch ((*GetSampleRightCopy)(Refcon,CurrentProcedure[
  2776.                                 ProgramCounter + 0].ImmediateString,
  2777.                                 (largefixedsigned**)&(Stack[StackPtr].Data.ArrayHandle->Array)))
  2778.                                 {
  2779.                                     case eEvalSampleNoError:
  2780.                                         CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  2781.                                         Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2782.                                         Stack[StackPtr].ElementType = esArray;
  2783.                                         break;
  2784.                                     case eEvalSampleUndefined:
  2785.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2786.                                         ErrorCode = eEvalGetSampleNotDefined;
  2787.                                         goto ExceptionPoint;
  2788.                                     case eEvalSampleWrongChannel:
  2789.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2790.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2791.                                         goto ExceptionPoint;
  2792.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2793.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2794.                                         ErrorCode = eEvalOutOfMemory;
  2795.                                         goto ExceptionPoint;
  2796.                                     default:
  2797.                                         EXECUTE(PRERR(ForceAbort,
  2798.                                             "EvaluatePcode [epGetSampleRightArray]: unknown return code"));
  2799.                                         break;
  2800.                                 }
  2801.                             ProgramCounter += 1;
  2802.                             break;
  2803.                         case epGetSampleMonoArray:
  2804.                             /*    -1           0    */
  2805.                             /* <opcode> ^"<namestring>" */
  2806.                             StackPtr += 1;
  2807.                             if (StackPtr >= StackSize)
  2808.                                 {
  2809.                                     StackElement*            NewStack;
  2810.  
  2811.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2812.                                         * sizeof(StackElement));
  2813.                                     if (NewStack == NIL)
  2814.                                         {
  2815.                                             StackPtr -= 1;
  2816.                                             ErrorCode = eEvalOutOfMemory;
  2817.                                             goto ExceptionPoint;
  2818.                                         }
  2819.                                     Stack = NewStack;
  2820.                                     StackSize += 8;
  2821.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2822.                                         PRERR(ForceAbort,"EvaluatePcode [epGetSampleMonoArray]: stack size inconsistency"));
  2823.                                 }
  2824.                             Stack[StackPtr].ElementType = esScalar;
  2825.                             PRNGCHK(CurrentProcedure,
  2826.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2827.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2828.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2829.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2830.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2831.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2832.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2833.                                 {
  2834.                                     ErrorCode = eEvalOutOfMemory;
  2835.                                     goto ExceptionPoint;
  2836.                                 }
  2837.                             switch ((*GetSampleMiddleCopy)(Refcon,CurrentProcedure[
  2838.                                 ProgramCounter + 0].ImmediateString,
  2839.                                 (largefixedsigned**)&(Stack[StackPtr].Data.ArrayHandle->Array)))
  2840.                                 {
  2841.                                     case eEvalSampleNoError:
  2842.                                         CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  2843.                                         Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2844.                                         Stack[StackPtr].ElementType = esArray;
  2845.                                         break;
  2846.                                     case eEvalSampleUndefined:
  2847.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2848.                                         ErrorCode = eEvalGetSampleNotDefined;
  2849.                                         goto ExceptionPoint;
  2850.                                     case eEvalSampleWrongChannel:
  2851.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2852.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2853.                                         goto ExceptionPoint;
  2854.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2855.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2856.                                         ErrorCode = eEvalOutOfMemory;
  2857.                                         goto ExceptionPoint;
  2858.                                     default:
  2859.                                         EXECUTE(PRERR(ForceAbort,
  2860.                                             "EvaluatePcode [epGetSampleMonoArray]: unknown return code"));
  2861.                                         break;
  2862.                                 }
  2863.                             ProgramCounter += 1;
  2864.                             break;
  2865.                         case epGetWaveTableArray:
  2866.                             /*    -1           0    */
  2867.                             /* <opcode> ^"<namestring>" */
  2868.                             StackPtr += 1;
  2869.                             if (StackPtr >= StackSize)
  2870.                                 {
  2871.                                     StackElement*            NewStack;
  2872.  
  2873.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2874.                                         * sizeof(StackElement));
  2875.                                     if (NewStack == NIL)
  2876.                                         {
  2877.                                             StackPtr -= 1;
  2878.                                             ErrorCode = eEvalOutOfMemory;
  2879.                                             goto ExceptionPoint;
  2880.                                         }
  2881.                                     Stack = NewStack;
  2882.                                     StackSize += 8;
  2883.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2884.                                         PRERR(ForceAbort,"EvaluatePcode [epGetWaveTableArray]: stack size inconsistency"));
  2885.                                 }
  2886.                             Stack[StackPtr].ElementType = esScalar;
  2887.                             PRNGCHK(CurrentProcedure,
  2888.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2889.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2890.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2891.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2892.                             Stack[StackPtr].Data.ArrayHandle = (ArrayHandleType*)AllocPtrCanFail(
  2893.                                 sizeof(ArrayHandleType),"ArrayHandleType");
  2894.                             if (Stack[StackPtr].Data.ArrayHandle == NIL)
  2895.                                 {
  2896.                                     ErrorCode = eEvalOutOfMemory;
  2897.                                     goto ExceptionPoint;
  2898.                                 }
  2899.                             switch ((*GetWaveTableCopy)(Refcon,CurrentProcedure[
  2900.                                 ProgramCounter + 0].ImmediateString,
  2901.                                 (largefixedsigned**)&(Stack[StackPtr].Data.ArrayHandle->Array)))
  2902.                                 {
  2903.                                     case eEvalSampleNoError:
  2904.                                         CheckPtrExistence(Stack[StackPtr].Data.ArrayHandle->Array);
  2905.                                         Stack[StackPtr].Data.ArrayHandle->RefCount = 1;
  2906.                                         Stack[StackPtr].ElementType = esArray;
  2907.                                         break;
  2908.                                     case eEvalSampleUndefined:
  2909.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2910.                                         ErrorCode = eEvalGetSampleNotDefined;
  2911.                                         goto ExceptionPoint;
  2912.                                     case eEvalSampleWrongChannel:
  2913.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2914.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2915.                                         goto ExceptionPoint;
  2916.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2917.                                         ReleasePtr((char*)(Stack[StackPtr].Data.ArrayHandle));
  2918.                                         ErrorCode = eEvalOutOfMemory;
  2919.                                         goto ExceptionPoint;
  2920.                                     default:
  2921.                                         EXECUTE(PRERR(ForceAbort,
  2922.                                             "EvaluatePcode [epGetWaveTableArray]: unknown return code"));
  2923.                                         break;
  2924.                                 }
  2925.                             ProgramCounter += 1;
  2926.                             break;
  2927.                         case epGetWaveTableFrames:
  2928.                             /*    -1           0    */
  2929.                             /* <opcode> ^"<namestring>" */
  2930.                             StackPtr += 1;
  2931.                             if (StackPtr >= StackSize)
  2932.                                 {
  2933.                                     StackElement*            NewStack;
  2934.  
  2935.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2936.                                         * sizeof(StackElement));
  2937.                                     if (NewStack == NIL)
  2938.                                         {
  2939.                                             StackPtr -= 1;
  2940.                                             ErrorCode = eEvalOutOfMemory;
  2941.                                             goto ExceptionPoint;
  2942.                                         }
  2943.                                     Stack = NewStack;
  2944.                                     StackSize += 8;
  2945.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2946.                                         PRERR(ForceAbort,"EvaluatePcode [epGetWaveTableFrames]: stack size inconsistency"));
  2947.                                 }
  2948.                             Stack[StackPtr].ElementType = esScalar;
  2949.                             PRNGCHK(CurrentProcedure,
  2950.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2951.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  2952.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  2953.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  2954.                             switch ((*GetWaveTableFrameCount)(Refcon,CurrentProcedure[
  2955.                                 ProgramCounter + 0].ImmediateString,&(Stack[StackPtr].Data.Integer)))
  2956.                                 {
  2957.                                     case eEvalSampleNoError:
  2958.                                         break;
  2959.                                     case eEvalSampleUndefined:
  2960.                                         ErrorCode = eEvalGetSampleNotDefined;
  2961.                                         goto ExceptionPoint;
  2962.                                     case eEvalSampleWrongChannel:
  2963.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  2964.                                         goto ExceptionPoint;
  2965.                                     case eEvalSampleNotEnoughMemoryToCopy:
  2966.                                         ErrorCode = eEvalOutOfMemory;
  2967.                                         goto ExceptionPoint;
  2968.                                     default:
  2969.                                         EXECUTE(PRERR(ForceAbort,
  2970.                                             "EvaluatePcode [epGetWaveTableFrames]: unknown return code"));
  2971.                                         break;
  2972.                                 }
  2973.                             ProgramCounter += 1;
  2974.                             break;
  2975.                         case epGetWaveTableTables:
  2976.                             /*    -1           0    */
  2977.                             /* <opcode> ^"<namestring>" */
  2978.                             StackPtr += 1;
  2979.                             if (StackPtr >= StackSize)
  2980.                                 {
  2981.                                     StackElement*            NewStack;
  2982.  
  2983.                                     NewStack = (StackElement*)ResizePtr((char*)Stack,(StackSize + 8)
  2984.                                         * sizeof(StackElement));
  2985.                                     if (NewStack == NIL)
  2986.                                         {
  2987.                                             StackPtr -= 1;
  2988.                                             ErrorCode = eEvalOutOfMemory;
  2989.                                             goto ExceptionPoint;
  2990.                                         }
  2991.                                     Stack = NewStack;
  2992.                                     StackSize += 8;
  2993.                                     ERROR(StackSize != PtrSize((char*)Stack) / sizeof(StackElement),
  2994.                                         PRERR(ForceAbort,"EvaluatePcode [epGetWaveTableTables]: stack size inconsistency"));
  2995.                                 }
  2996.                             Stack[StackPtr].ElementType = esScalar;
  2997.                             PRNGCHK(CurrentProcedure,
  2998.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  2999.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  3000.                             CheckPtrExistence(CurrentProcedure[ProgramCounter + 0].ImmediateString);
  3001.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  3002.                             switch ((*GetWaveTableTableCount)(Refcon,CurrentProcedure[
  3003.                                 ProgramCounter + 0].ImmediateString,&(Stack[StackPtr].Data.Integer)))
  3004.                                 {
  3005.                                     case eEvalSampleNoError:
  3006.                                         break;
  3007.                                     case eEvalSampleUndefined:
  3008.                                         ErrorCode = eEvalGetSampleNotDefined;
  3009.                                         goto ExceptionPoint;
  3010.                                     case eEvalSampleWrongChannel:
  3011.                                         ErrorCode = eEvalGetSampleWrongChannelType;
  3012.                                         goto ExceptionPoint;
  3013.                                     case eEvalSampleNotEnoughMemoryToCopy:
  3014.                                         ErrorCode = eEvalOutOfMemory;
  3015.                                         goto ExceptionPoint;
  3016.                                     default:
  3017.                                         EXECUTE(PRERR(ForceAbort,
  3018.                                             "EvaluatePcode [epGetWaveTableTables]: unknown return code"));
  3019.                                         break;
  3020.                                 }
  3021.                             ProgramCounter += 1;
  3022.                             break;
  3023.  
  3024.                         case epPrintString:
  3025.                             /*    -1            0    */
  3026.                             /* <opcode> ^"<string>" */
  3027.                             PRNGCHK(CurrentProcedure,
  3028.                                 &(CurrentProcedure[ProgramCounter + 0].ImmediateString),
  3029.                                 sizeof(CurrentProcedure[ProgramCounter + 0].ImmediateString));
  3030.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  3031.                             {
  3032.                                 InteractionWindowRec*        Interaction;
  3033.  
  3034.                                 Interaction = (*GetInteractionWindow)(IRefCon);
  3035.                                 if (Interaction == NIL)
  3036.                                     {
  3037.                                         ErrorCode = eEvalOutOfMemory;
  3038.                                         goto ExceptionPoint;
  3039.                                     }
  3040.                                 if (!InteractionWindowAppendString(Interaction,
  3041.                                     CurrentProcedure[ProgramCounter + 0].ImmediateString,
  3042.                                     StrLen(CurrentProcedure[ProgramCounter + 0].ImmediateString)))
  3043.                                     {
  3044.                                         ErrorCode = eEvalOutOfMemory;
  3045.                                         goto ExceptionPoint;
  3046.                                     }
  3047.                             }
  3048.                             WizzBangCount = 0;
  3049.                             ProgramCounter += 1;
  3050.                             break;
  3051.                         case epPrintBool: /* <opcode> */
  3052.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  3053.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  3054.                                 ,PRERR(ForceAbort,
  3055.                                 "EvaluatePcode [epPrintBool]: bad stack element type"));
  3056.                             if (Stack[StackPtr].Data.Integer)
  3057.                                 {
  3058.                                     InteractionWindowRec*        Interaction;
  3059.  
  3060.                                     Interaction = (*GetInteractionWindow)(IRefCon);
  3061.                                     if (Interaction == NIL)
  3062.                                         {
  3063.                                             ErrorCode = eEvalOutOfMemory;
  3064.                                             goto ExceptionPoint;
  3065.                                         }
  3066.                                     if (!InteractionWindowAppendString(Interaction,"true",4))
  3067.                                         {
  3068.                                             ErrorCode = eEvalOutOfMemory;
  3069.                                             goto ExceptionPoint;
  3070.                                         }
  3071.                                 }
  3072.                              else
  3073.                                 {
  3074.                                     InteractionWindowRec*        Interaction;
  3075.  
  3076.                                     Interaction = (*GetInteractionWindow)(IRefCon);
  3077.                                     if (Interaction == NIL)
  3078.                                         {
  3079.                                             ErrorCode = eEvalOutOfMemory;
  3080.                                             goto ExceptionPoint;
  3081.                                         }
  3082.                                     if (!InteractionWindowAppendString(Interaction,"false",5))
  3083.                                         {
  3084.                                             ErrorCode = eEvalOutOfMemory;
  3085.                                             goto ExceptionPoint;
  3086.                                         }
  3087.                                 }
  3088.                             StackPtr -= 1;
  3089.                             WizzBangCount = 0;
  3090.                             break;
  3091.                         case epPrintDouble: /* <opcode> */
  3092.                             PRNGCHK(Stack,&(Stack[StackPtr]),sizeof(Stack[StackPtr]));
  3093.                             ERROR((Stack[StackPtr].ElementType != esScalar)
  3094.                                 ,PRERR(ForceAbort,
  3095.                                 "EvaluatePcode [epPrintDouble]: bad stack element type"));
  3096.                             {
  3097.                                 char*                            Stuff;
  3098.                                 InteractionWindowRec*        Interaction;
  3099.  
  3100.                                 Interaction = (*GetInteractionWindow)(IRefCon);
  3101.                                 if (Interaction == NIL)
  3102.                                     {
  3103.                                         ErrorCode = eEvalOutOfMemory;
  3104.                                         goto ExceptionPoint;
  3105.                                     }
  3106.                                 Stuff = LongDoubleToString(Stack[StackPtr].Data.Double,
  3107.                                     15,1e-4,4294967296.0);
  3108.                                 if (Stuff == NIL)
  3109.                                     {
  3110.                                         ErrorCode = eEvalOutOfMemory;
  3111.                                         goto ExceptionPoint;
  3112.                                     }
  3113.                                 if (!InteractionWindowAppendString(Interaction,Stuff,PtrSize(Stuff)))
  3114.                                     {
  3115.                                         ReleasePtr(Stuff);
  3116.                                         ErrorCode = eEvalOutOfMemory;
  3117.                                         goto ExceptionPoint;
  3118.                                     }
  3119.                                 ReleasePtr(Stuff);
  3120.                             }
  3121.                             StackPtr -= 1;
  3122.                             WizzBangCount = 0;
  3123.                             break;
  3124.  
  3125.                     } /* end switch */
  3126.             } /* end while */
  3127.  
  3128.  
  3129.         /* when something bad happens, set the ErrorCode with the error code and */
  3130.         /* jump here.  this will release all allocated arrays on the stack and in */
  3131.         /* the registers, set the offending function pcode, and return */
  3132.      ExceptionPoint:
  3133.         /* first, release all objects */
  3134.         while (StackPtr != GetStackNumElements(Prep) - 1)
  3135.             {
  3136.                 /* pop all elements except those that were there originally */
  3137.                 if ((Stack[StackPtr].ElementType == esArray)
  3138.                     && (Stack[StackPtr].Data.ArrayHandle != NIL))
  3139.                     {
  3140.                         DisposeIfNotOnStack(Stack,StackPtr);
  3141.                     }
  3142.                 StackPtr -= 1;
  3143.             }
  3144.         /* then set up the error values */
  3145.         *OffendingPcode = CurrentProcedure;
  3146.         *OffendingInstruction = ProgramCounter - 1;
  3147.         /* write back values that might have changed */
  3148.         SetStackInformation(Prep,StackSize,StackPtr + 1,Stack);
  3149.         return ErrorCode;
  3150.  
  3151.  
  3152.         /* when execution finishes, jump here.  The lowest element [0] in the stack will */
  3153.         /* have the return value, placed there according to calling conventions */
  3154.      TotallyDonePoint:
  3155.         /* check stack pointer */
  3156.         ERROR(StackPtr != GetStackNumElements(Prep) - 1,PRERR(ForceAbort,
  3157.             "EvaluatePcode:  normal exit, but final stack pointer != initial stack pointer"));
  3158.         /* write back values that might have changed */
  3159.         SetStackInformation(Prep,StackSize,StackPtr + 1,Stack);
  3160.         /* return message that indicates everything went fine */
  3161.         return eEvalNoError;
  3162.     }
  3163.  
  3164.  
  3165. char*                            GetPcodeErrorMessage(EvalErrors Error)
  3166.     {
  3167.         char*                        ErrorString;
  3168.  
  3169.         switch (Error)
  3170.             {
  3171.                 default:
  3172.                     EXECUTE(PRERR(ForceAbort,"GetPcodeErrorMessage:  unknown error code"));
  3173.                     break;
  3174.                 case eEvalUndefinedFunction:
  3175.                     ErrorString = "Called an undefined function.";
  3176.                     break;
  3177.                 case eEvalErrorTrapEncountered:
  3178.                     ErrorString = "Error trap encountered; user cancelled execution.";
  3179.                     break;
  3180.                 case eEvalUserCancelled:
  3181.                     ErrorString = "User cancelled.";
  3182.                     break;
  3183.                 case eEvalDivideByZero:
  3184.                     ErrorString = "Divide by zero.";
  3185.                     break;
  3186.                 case eEvalOutOfMemory:
  3187.                     ErrorString = "Out of memory.";
  3188.                     break;
  3189.                 case eEvalArrayDoesntExist:
  3190.                     ErrorString = "Use of unallocated (NIL) array.";
  3191.                     break;
  3192.                 case eEvalArraySubscriptOutOfRange:
  3193.                     ErrorString = "Array subscript out of range.";
  3194.                     break;
  3195.                 case eEvalGetSampleNotDefined:
  3196.                     ErrorString = "Attempt to access undefined sample or wave table.";
  3197.                     break;
  3198.                 case eEvalGetSampleWrongChannelType:
  3199.                     ErrorString = "Attempt to load sample array with wrong channel type.";
  3200.                     break;
  3201.                 case eEvalWrongNumParametersForFunction:
  3202.                     ErrorString = "Wrong number of parameters for function call.";
  3203.                     break;
  3204.                 case eEvalWrongParameterType:
  3205.                     ErrorString = "Parameter for function call does not match function's type.";
  3206.                     break;
  3207.                 case eEvalWrongReturnType:
  3208.                     ErrorString = "Return type for function call does not match function's type.";
  3209.                     break;
  3210.             }
  3211.         return ErrorString;
  3212.     }
  3213.